Swing中的线程 －－invokeLater

Swing中的线程有三种：初始线程，事件线程，工作线程

这三种线程基本上包括了让一个GUI完美工作的方方面面，首先，初始线程被用来创建GUI组件、资源加载和启动GUI组件，众所周知，Swing是事件驱动的，所以当UI出现了之后，初始线程就完成了它的使命，并将接力棒交给了事件线程,Event Dispatch Thread，这个时候所有组件的事件行为都交给了这个线程去处理，当然我们自己也要需要用线程来运行许多任务，优秀的GUI程序是绝不能让界面被卡死不动的，那会让用户崩溃，所以这个时候就需要工作线程了，也可以说是在背后运行的线程，这种线程是劳动阶级，任劳任怨的执行者长时间的工作。

现在我们要做一个简单的界面，包括一个进度条、一个输入框、开始和停止按钮。

需要实现的功能是：

当点击开始按钮，则更新进度条，并且在输入框内把完成的百分比输出。

 

代码1：

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：

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：

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()方法。