`
jxxms
  • 浏览: 106880 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

Swing 线程之SwingUtilities.invokeLater()

SwingGothread工作 
阅读更多

现在我们要做一个简单的界面。

包括一个进度条、一个输入框、开始和停止按钮。

需要实现的功能是：

当点击开始按钮，则更新进度条，并且在输入框内把完成的百分比输出(这里只做例子，没有真正去做某个工作)。

 

代码1：

view plaincopy to clipboardprint?
import java.awt.FlowLayout;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
import javax.swing.JButton;  
import javax.swing.JFrame;  
import javax.swing.JProgressBar;  
import javax.swing.JTextField;  
public class SwingThreadTest1 extends JFrame {  
    private static final long serialVersionUID = 1L;  
    private static final String STR = "Completed : ";  
    private JProgressBar progressBar = new JProgressBar();  
    private JTextField text = new JTextField(10);  
    private JButton start = new JButton("Start");  
    private JButton end = new JButton("End");  
    private boolean flag = false;  
    private int count = 0;  
    public SwingThreadTest1() {  
        this.setLayout(new FlowLayout());  
        add(progressBar);  
        text.setEditable(false);  
        add(text);  
        add(start);  
        add(end);  
        start.addActionListener(new Start());  
        end.addActionListener(new End());  
    }  
          
    private void go() {  
        while (count < 100) {  
            try {  
                Thread.sleep(100);//这里比作要完成的某个耗时的工作  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
                         //更新进度条和输入框  
            if (flag) {  
                count++;  
                progressBar.setValue(count);  
                text.setText(STR + String.valueOf(count) + "%");  
            }  
        }  
    }  
    private class Start implements ActionListener {  
        public void actionPerformed(ActionEvent e) {  
            flag = true;//设置开始更新的标志  
            go();//开始工作  
        }  
    }  
    private class End implements ActionListener {  
        public void actionPerformed(ActionEvent e) {  
            flag = false;//停止  
        }  
    }  
    public static void main(String[] args) {  
        SwingThreadTest1 fg = new SwingThreadTest1();  
        fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        fg.setSize(300, 100);  
        fg.setVisible(true);  
    }  
} 
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JProgressBar;
import javax.swing.JTextField;
public class SwingThreadTest1 extends JFrame {
 private static final long serialVersionUID = 1L;
 private static final String STR = "Completed : ";
 private JProgressBar progressBar = new JProgressBar();
 private JTextField text = new JTextField(10);
 private JButton start = new JButton("Start");
 private JButton end = new JButton("End");
 private boolean flag = false;
 private int count = 0;
 public SwingThreadTest1() {
  this.setLayout(new FlowLayout());
  add(progressBar);
  text.setEditable(false);
  add(text);
  add(start);
  add(end);
  start.addActionListener(new Start());
  end.addActionListener(new End());
 }
       
 private void go() {
  while (count < 100) {
   try {
    Thread.sleep(100);//这里比作要完成的某个耗时的工作
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
                         //更新进度条和输入框
   if (flag) {
    count++;
    progressBar.setValue(count);
    text.setText(STR + String.valueOf(count) + "%");
   }
  }
 }
 private class Start implements ActionListener {
  public void actionPerformed(ActionEvent e) {
   flag = true;//设置开始更新的标志
   go();//开始工作
  }
 }
 private class End implements ActionListener {
  public void actionPerformed(ActionEvent e) {
   flag = false;//停止
  }
 }
 public static void main(String[] args) {
  SwingThreadTest1 fg = new SwingThreadTest1();
  fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  fg.setSize(300, 100);
  fg.setVisible(true);
 }
}
 

 

运行代码发现，

现象1：当点击了开始按钮，画面就卡住了。按钮不能点击，进度条没有被更新，输入框上也没有任何信息。

原因分析：Swing是线程不安全的，是单线程的设计，所以只能从事件派发线程访问将要在屏幕上绘制的Swing组件。ActionListener的actionPerformed方法是在事件派发线程中调用执行的，而点击了开始按钮后，执行了go()方法，在go()里，虽然也去执行了更新组件的方法

progressBar.setValue(count);

text.setText(STR + String.valueOf(count) + "%");

但由于go()方法直到循环结束，它并没有返回，所以更新组件的操作一直没有被执行，这就造成了画面卡住的现象。

现象2：过了一段时间(go方法里的循环结束了)后，画面又可以操作，并且进度条被更新，输入框也出现了我们想看到的信息。

原因分析：通过在现象1的分析，很容易联想到，当go()方法返回了，则其他的线程(更新组件)可以被派发了，所以画面上的组件被更新了。

为了让画面不会卡住，我们来修改代码，将耗时的工作放在一个线程里去做。

 


代码2：

view plaincopy to clipboardprint?
import java.awt.FlowLayout;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
import javax.swing.JButton;  
import javax.swing.JFrame;  
import javax.swing.JProgressBar;  
import javax.swing.JTextField;  
public class SwingThreadTest2 extends JFrame {  
    private static final long serialVersionUID = 1L;  
    private static final String STR = "Completed : ";  
    private JProgressBar progressBar = new JProgressBar();  
    private JTextField text = new JTextField(10);  
    private JButton start = new JButton("Start");  
    private JButton end = new JButton("End");  
    private boolean flag = false;  
    private int count = 0;  
      
    GoThread t = null;  
    public SwingThreadTest2() {  
        this.setLayout(new FlowLayout());  
        add(progressBar);  
        text.setEditable(false);  
        add(text);  
        add(start);  
        add(end);  
        start.addActionListener(new Start());  
        end.addActionListener(new End());  
    }  
    private void go() {  
        while (count < 100) {  
            try {  
                Thread.sleep(100);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            if (flag) {  
                count++;  
                System.out.println(count);  
                progressBar.setValue(count);  
                text.setText(STR + String.valueOf(count) + "%");  
            }  
        }  
    }  
    private class Start implements ActionListener {  
        public void actionPerformed(ActionEvent e) {  
            flag = true;  
            if(t == null){  
                t = new GoThread();  
                t.start();  
            }  
        }  
    }  
    //执行复杂工作，然后更新组件的线程  
    class GoThread extends Thread{  
        public void run() {  
            //do something...  
            go();  
        }  
    }  
    private class End implements ActionListener {  
        public void actionPerformed(ActionEvent e) {  
            flag = false;  
        }  
    }  
    public static void main(String[] args) {  
        SwingThreadTest2 fg = new SwingThreadTest2();  
        fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        fg.setSize(300, 100);  
        fg.setVisible(true);  
    }  
} 
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JProgressBar;
import javax.swing.JTextField;
public class SwingThreadTest2 extends JFrame {
 private static final long serialVersionUID = 1L;
 private static final String STR = "Completed : ";
 private JProgressBar progressBar = new JProgressBar();
 private JTextField text = new JTextField(10);
 private JButton start = new JButton("Start");
 private JButton end = new JButton("End");
 private boolean flag = false;
 private int count = 0;
 
 GoThread t = null;
 public SwingThreadTest2() {
  this.setLayout(new FlowLayout());
  add(progressBar);
  text.setEditable(false);
  add(text);
  add(start);
  add(end);
  start.addActionListener(new Start());
  end.addActionListener(new End());
 }
 private void go() {
  while (count < 100) {
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   if (flag) {
    count++;
    System.out.println(count);
    progressBar.setValue(count);
    text.setText(STR + String.valueOf(count) + "%");
   }
  }
 }
 private class Start implements ActionListener {
  public void actionPerformed(ActionEvent e) {
   flag = true;
   if(t == null){
    t = new GoThread();
    t.start();
   }
  }
 }
 //执行复杂工作，然后更新组件的线程
 class GoThread extends Thread{
  public void run() {
   //do something...
   go();
  }
 }
 private class End implements ActionListener {
  public void actionPerformed(ActionEvent e) {
   flag = false;
  }
 }
 public static void main(String[] args) {
  SwingThreadTest2 fg = new SwingThreadTest2();
  fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  fg.setSize(300, 100);
  fg.setVisible(true);
 }
}
 

 

我们执行了程序，结果和我们想要的一样，画面不会卡住了。

那这个程序是否没有问题了呢？

我们自定义了一个线程GoThread，在这里我们完成了那些耗时的工作，可以看作是“工作线程”，

而对于组件的更新，我们也放在了“工作线程”里完成了。

在这里，在事件派发线程以外的线程里设置进度条，是一个危险的操作，运行是不正常的。（对于输入框组件的更新是安全的。）

 

只有从事件派发线程才能更新组件，根据这个原则，我们来修改我们现有代码。

代码3：

view plaincopy to clipboardprint?
import java.awt.FlowLayout;  
import java.awt.event.ActionEvent;  
import java.awt.event.ActionListener;  
import javax.swing.JButton;  
import javax.swing.JFrame;  
import javax.swing.JProgressBar;  
import javax.swing.JTextField;  
import javax.swing.SwingUtilities;  
public class SwingThreadTest3 extends JFrame {  
    private static final long serialVersionUID = 1L;  
    private static final String STR = "Completed : ";  
    private JProgressBar progressBar = new JProgressBar();  
    private JTextField text = new JTextField(10);  
    private JButton start = new JButton("Start");  
    private JButton end = new JButton("End");  
    private boolean flag = false;  
    private int count = 0;  
      
    private GoThread t = null;  
      
    private Runnable run = null;//更新组件的线程  
    public SwingThreadTest3() {  
        this.setLayout(new FlowLayout());  
        add(progressBar);  
        text.setEditable(false);  
        add(text);  
        add(start);  
        add(end);  
        start.addActionListener(new Start());  
        end.addActionListener(new End());  
          
        run = new Runnable(){//实例化更新组件的线程  
            public void run() {  
                progressBar.setValue(count);  
                text.setText(STR + String.valueOf(count) + "%");  
            }  
        };  
    }  
    private void go() {  
        while (count < 100) {  
            try {  
                Thread.sleep(100);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            if (flag) {  
                count++;  
                SwingUtilities.invokeLater(run);//将对象排到事件派发线程的队列中  
            }  
        }  
    }  
    private class Start implements ActionListener {  
        public void actionPerformed(ActionEvent e) {  
            flag = true;  
            if(t == null){  
                t = new GoThread();  
                t.start();  
            }  
        }  
    }  
      
    class GoThread extends Thread{  
        public void run() {  
            //do something...  
            go();  
        }  
    }  
    private class End implements ActionListener {  
        public void actionPerformed(ActionEvent e) {  
            flag = false;  
        }  
    }  
    public static void main(String[] args) {  
        SwingThreadTest3 fg = new SwingThreadTest3();  
        fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        fg.setSize(300, 100);  
        fg.setVisible(true);  
    }  
} 
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JProgressBar;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
public class SwingThreadTest3 extends JFrame {
 private static final long serialVersionUID = 1L;
 private static final String STR = "Completed : ";
 private JProgressBar progressBar = new JProgressBar();
 private JTextField text = new JTextField(10);
 private JButton start = new JButton("Start");
 private JButton end = new JButton("End");
 private boolean flag = false;
 private int count = 0;
 
 private GoThread t = null;
 
 private Runnable run = null;//更新组件的线程
 public SwingThreadTest3() {
  this.setLayout(new FlowLayout());
  add(progressBar);
  text.setEditable(false);
  add(text);
  add(start);
  add(end);
  start.addActionListener(new Start());
  end.addActionListener(new End());
  
  run = new Runnable(){//实例化更新组件的线程
   public void run() {
    progressBar.setValue(count);
    text.setText(STR + String.valueOf(count) + "%");
   }
  };
 }
 private void go() {
  while (count < 100) {
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   if (flag) {
    count++;
    SwingUtilities.invokeLater(run);//将对象排到事件派发线程的队列中
   }
  }
 }
 private class Start implements ActionListener {
  public void actionPerformed(ActionEvent e) {
   flag = true;
   if(t == null){
    t = new GoThread();
    t.start();
   }
  }
 }
 
 class GoThread extends Thread{
  public void run() {
   //do something...
   go();
  }
 }
 private class End implements ActionListener {
  public void actionPerformed(ActionEvent e) {
   flag = false;
  }
 }
 public static void main(String[] args) {
  SwingThreadTest3 fg = new SwingThreadTest3();
  fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  fg.setSize(300, 100);
  fg.setVisible(true);
 }
}
 

 

解释：SwingUtilities.invokeLater()方法使事件派发线程上的可运行对象排队。当可运行对象排在事件派发队列的队首时，就调用其run方法。其效果是允许事件派发线程调用另一个线程中的任意一个代码块。

还有一个方法SwingUtilities.invokeAndWait()方法，它也可以使事件派发线程上的可运行对象排队。

他们的不同之处在于：SwingUtilities.invokeLater()在把可运行的对象放入队列后就返回，而SwingUtilities.invokeAndWait()一直等待知道已启动了可运行的run方法才返回。如果一个操作在另外一个操作执行之前必须从一个组件获得信息，则应使用SwingUtilities.invokeAndWait()方法。

 

分享到：
| p2p
评论
1 楼 gaohongliang 2011-11-16  
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Swing 线程之SwingUtilities invokeLater docx

    Swing 线程之 SwingUtilities invokeLater Swing 线程模型是 Java 中一个非常重要的概念，它是 Java 的图形用户界面（GUI）程序设计中的一部分。Swing 是基于 MVC 模式（Model-View-Controller）设计的，它提供了一...

    Swing线程之SwingUtilities.invoke

    Swing线程机制是Swing库中的关键概念，它确保了所有对Swing组件的操作都在正确的线程——事件分发线程（Event Dispatch Thread，简称EDT）上执行，以避免线程安全问题和界面更新不一致的情况。`SwingUtilities....

    Swing线程基础可用.pdf

    Swing线程基础是Java GUI编程中的重要概念，特别是对于使用Swing库构建的应用程序而言。Swing设计遵循单一线程原则，确保图形用户界面（GUI）的稳定性和响应性。以下是Swing线程基础的详细说明： 1. **初始化线程 ...

    Java开发中的线程安全选择与Swing

    Swing组件默认不是线程安全的，因此必须通过`SwingUtilities.invokeLater()`、`SwingUtilities.invokeAndWait()`或使用`SwingWorker`类来确保所有对Swing组件的操作都在事件分发线程中执行。这些技术的应用可以有效...

    再论JavaSwing线程.pdf

    `SwingUtilities.invokeLater()`通常用于将任务插入到事件队列中，以便在下一个事件循环中由Swing线程执行。而`SwingWorker`则提供了更高级的功能，可以在后台线程执行计算，并在完成后更新UI。`SwingWorker`允许你...

    Swing线程基础.pdf

    Swing线程基础是Java GUI编程中的关键概念，主要涉及Swing应用程序中三种类型的线程：初始化线程、UI事件调度线程（EDT，Event Dispatch Thread）和任务线程（Worker Thread）。这些线程在Swing应用中各有其职责，以...

    Swing组建中EventQueue的使用

    Swing是单线程模型，这意味着所有的UI更新都必须在称为“事件调度线程”（Event Dispatch Thread, EDT）的线程中执行。这是为了确保界面始终是响应式的，避免因为长时间的计算任务阻塞用户界面。`EventQueue`就是这...

    JAVA 开发 Swing与多线程

    总的来说，理解和利用Swing的单线程模型以及`SwingUtilities.invokeLater()`方法是Java GUI编程的关键。正确地在EDT中处理任务和更新组件可以确保界面的响应性和一致性，避免因多线程导致的问题。在编写Swing应用时...

    Java Swing多线程死锁问题解析

    代码执行前判断是否处于Swing线程当中（使用SwingUtilities.isEventDispatchThread()方法），如果不是，则需要通过SwingUtilities.invokeLater(Runnable)执行，否则则直接执行代码。 在Java Swing多线程死锁问题...

    swing 显示时间

    在本例中，我们将探讨如何利用Swing来显示当前时间，并结合多线程的概念确保时间的实时更新。 首先，`Show.java`文件很可能包含了一个Java类，该类创建了一个Swing窗口并在其中显示时间。Swing中的`JFrame`是窗口的...

    code3.txt dfgd

    SwingUtilities.invokeLater方法用于确保Swing组件的创建和操作在事件分发线程（EDT）上执行，这是因为Swing是单线程的，所有的用户界面更新都需要在EDT上进行以避免线程安全问题。 ### JavaFX的SwingNode组件 ...

    Swing中的线程研究.pdf

    - **更新界面**：如果需要在非EDT线程中修改GUI组件，如`jLabel1.setText("blabla")`，必须使用`SwingUtilities.invokeLater()`来调度任务。这是因为Swing的线程安全规则，只有在EDT中才能直接修改组件。 - **...

    你所不知道的五件事情--改进Swing(译) - Jiangshachina

    ### 你所不知道的五件事—改进Swing ...无论是通过Substance提供的外观定制能力，还是SwingX中强大的组件库，亦或是对Swing线程机制的深入理解，都能够帮助开发者创建出更加现代化、高效的Swing应用。

    如何用java实现下拉菜单

    然后，在`main`方法中，我们使用`SwingUtilities.invokeLater()`来确保所有GUI操作都在事件调度线程中执行。这很重要，因为Swing组件必须在事件调度线程中创建和修改。 接下来，我们创建了一个`JFrame`实例，用于...

    简单的排球比赛计分系统，使用Java Swing实现

    程序创建一个窗口，包含输入分数的文本框、计分按钮、查询按钮、显示比分的文本区域和退出按钮。用户可以通过输入分数进行计分，通过查询按钮...最后，通过SwingUtilities.invokeLater方法确保在正确的线程中运行程序。

    java Swing的使用.docx

    在创建Swing应用时，通常需要遵循一些最佳实践，例如使用`SwingUtilities.invokeLater()`方法来启动GUI。这是因为Swing不是线程安全的，所有的组件操作必须在事件分派线程（Event Dispatch Thread, EDT）中进行，以...

    Javaswing多线程.zip

    6. **SwingUtilities.invokeLater()**：为了确保所有的UI操作都在EDT上进行，开发者可能使用这个方法来启动GUI。这样可以保证UI的线程安全，避免出现因非EDT操作导致的错误。 7. **Thread.sleep()**：虽然在Swing...

    Java Swing 24种皮肤合集以及使用方法

    可以使用`SwingUtilities.invokeLater()`来确保这一点： ```java SwingUtilities.invokeLater(() -&gt; { // 设置LookAndFeel的代码放在这里 }); ``` 4. **重新绘制所有组件**： 设置完L&F后，需要更新所有的...

    Swing线程基础经典

    - **方法一：异步处理** - 使用`SwingUtilities.invokeLater()`或`invokeAndWait()`将UI更新操作包装在一个新的Runnble中，并放入EDT队列。这样可以确保更新操作在EDT上下文中执行，而不会阻塞其他事件的处理。 - ...

Magicbox
Global site tag (gtag.js) - Google Analytics