java解决swing单线程卡死

现在我们要做一个简单的界面。
包括一个进度条、一个输入框、开始和停止按钮。
需要实现的功能是：
当点击开始按钮，则更新进度条，并且在输入框内把完成的百分比输出(这里只做例子，没有真正去做某个工作)。

代码1：
view plaincopy to clipboardprint?
1. import java.awt.FlowLayout; 
2. import java.awt.event.ActionEvent; 
3. import java.awt.event.ActionListener; 
4. import javax.swing.JButton; 
5. import javax.swing.JFrame; 
6. import javax.swing.JProgressBar; 
7. import javax.swing.JTextField; 
8. public class SwingThreadTest1 extends JFrame { 
9.        private static final long serialVersionUID = 1L; 
10.        private static final String STR = "Completed : "; 
11.        private JProgressBar progressBar = new JProgressBar(); 
12.        private JTextField text = new JTextField(10); 
13.        private JButton start = new JButton("Start"); 
14.        private JButton end = new JButton("End"); 
15.        private boolean flag = false; 
16.        private int count = 0; 
17.        public SwingThreadTest1() { 
18.          this.setLayout(new FlowLayout()); 
19.          add(progressBar); 
20.          text.setEditable(false); 
21.          add(text); 
22.          add(start); 
23.          add(end); 
24.          start.addActionListener(new Start()); 
25.          end.addActionListener(new End()); 
26.        } 
27.            
28.        private void go() { 
29.          while (count < 100) { 
30.             try { 
31.                    Thread.sleep(100);//这里比作要完成的某个耗时的工作 
32.             } catch (InterruptedException e) { 
33.                    e.printStackTrace(); 
34.             } 
35.                             //更新进度条和输入框 
36.             if (flag) { 
37.                    count++; 
38.                    progressBar.setValue(count); 
39.                    text.setText(STR + String.valueOf(count) + "%"); 
40.             } 
41.          } 
42.        } 
43.        private class Start implements ActionListener { 
44.          public void actionPerformed(ActionEvent e) { 
45.             flag = true;//设置开始更新的标志 
46.             go();//开始工作 
47.          } 
48.        } 
49.        private class End implements ActionListener { 
50.          public void actionPerformed(ActionEvent e) { 
51.             flag = false;//停止 
52.          } 
53.        } 
54.        public static void main(String[] args) { 
55.          SwingThreadTest1 fg = new SwingThreadTest1(); 
56.          fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
57.          fg.setSize(300, 100); 
58.          fg.setVisible(true); 
59.        } 
60. } 

运行代码发现，
现象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?
1. import java.awt.FlowLayout; 
2. import java.awt.event.ActionEvent; 
3. import java.awt.event.ActionListener; 
4. import javax.swing.JButton; 
5. import javax.swing.JFrame; 
6. import javax.swing.JProgressBar; 
7. import javax.swing.JTextField; 
8. public class SwingThreadTest2 extends JFrame { 
9.        private static final long serialVersionUID = 1L; 
10.        private static final String STR = "Completed : "; 
11.        private JProgressBar progressBar = new JProgressBar(); 
12.        private JTextField text = new JTextField(10); 
13.        private JButton start = new JButton("Start"); 
14.        private JButton end = new JButton("End"); 
15.        private boolean flag = false; 
16.        private int count = 0; 
17.      
18.        GoThread t = null; 
19.        public SwingThreadTest2() { 
20.          this.setLayout(new FlowLayout()); 
21.          add(progressBar); 
22.          text.setEditable(false); 
23.          add(text); 
24.          add(start); 
25.          add(end); 
26.          start.addActionListener(new Start()); 
27.          end.addActionListener(new End()); 
28.        } 
29.        private void go() { 
30.          while (count < 100) { 
31.             try { 
32.                    Thread.sleep(100); 
33.             } catch (InterruptedException e) { 
34.                    e.printStackTrace(); 
35.             } 
36.             if (flag) { 
37.                    count++; 
38.                    System.out.println(count); 
39.                    progressBar.setValue(count); 
40.                    text.setText(STR + String.valueOf(count) + "%"); 
41.             } 
42.          } 
43.        } 
44.        private class Start implements ActionListener { 
45.          public void actionPerformed(ActionEvent e) { 
46.             flag = true; 
47.             if(t == null){ 
48.                    t = new GoThread(); 
49.                    t.start(); 
50.             } 
51.          } 
52.        } 
53.        //执行复杂工作，然后更新组件的线程 
54.        class GoThread extends Thread{ 
55.          public void run() { 
56.             //do something... 
57.             go(); 
58.          } 
59.        } 
60.        private class End implements ActionListener { 
61.          public void actionPerformed(ActionEvent e) { 
62.             flag = false; 
63.          } 
64.        } 
65.        public static void main(String[] args) { 
66.          SwingThreadTest2 fg = new SwingThreadTest2(); 
67.          fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
68.          fg.setSize(300, 100); 
69.          fg.setVisible(true); 
70.        } 
71. } 

我们执行了程序，结果和我们想要的一样，画面不会卡住了。
那这个程序是否没有问题了呢？
我们自定义了一个线程GoThread，在这里我们完成了那些耗时的工作，可以看作是“工作线程”，
而对于组件的更新，我们也放在了“工作线程”里完成了。
在这里，在事件派发线程以外的线程里设置进度条，是一个危险的操作，运行是不正常的。（对于输入框组件的更新是安全的。）

只有从事件派发线程才能更新组件，根据这个原则，我们来修改我们现有代码。
代码3：
view plaincopy to clipboardprint?
1. import java.awt.FlowLayout; 
2. import java.awt.event.ActionEvent; 
3. import java.awt.event.ActionListener; 
4. import javax.swing.JButton; 
5. import javax.swing.JFrame; 
6. import javax.swing.JProgressBar; 
7. import javax.swing.JTextField; 
8. import javax.swing.SwingUtilities; 
9. public class SwingThreadTest3 extends JFrame { 
10.        private static final long serialVersionUID = 1L; 
11.        private static final String STR = "Completed : "; 
12.        private JProgressBar progressBar = new JProgressBar(); 
13.        private JTextField text = new JTextField(10); 
14.        private JButton start = new JButton("Start"); 
15.        private JButton end = new JButton("End"); 
16.        private boolean flag = false; 
17.        private int count = 0; 
18.      
19.        private GoThread t = null; 
20.      
21.        private Runnable run = null;//更新组件的线程 
22.        public SwingThreadTest3() { 
23.          this.setLayout(new FlowLayout()); 
24.          add(progressBar); 
25.          text.setEditable(false); 
26.          add(text); 
27.          add(start); 
28.          add(end); 
29.          start.addActionListener(new Start()); 
30.          end.addActionListener(new End()); 
31.            
32.          run = new Runnable(){//实例化更新组件的线程 
33.             public void run() { 
34.                    progressBar.setValue(count); 
35.                    text.setText(STR + String.valueOf(count) + "%"); 
36.             } 
37.          }; 
38.        } 
39.        private void go() { 
40.          while (count < 100) { 
41.             try { 
42.                    Thread.sleep(100); 
43.             } catch (InterruptedException e) { 
44.                    e.printStackTrace(); 
45.             } 
46.             if (flag) { 
47.                    count++; 
48.                    SwingUtilities.invokeLater(run);//将对象排到事件派发线程的队列中 
49.             } 
50.          } 
51.        } 
52.        private class Start implements ActionListener { 
53.          public void actionPerformed(ActionEvent e) { 
54.             flag = true; 
55.             if(t == null){ 
56.                    t = new GoThread(); 
57.                    t.start(); 
58.             } 
59.          } 
60.        } 
61.      
62.        class GoThread extends Thread{ 
63.          public void run() { 
64.             //do something... 
65.             go(); 
66.          } 
67.        } 
68.        private class End implements ActionListener { 
69.          public void actionPerformed(ActionEvent e) { 
70.             flag = false; 
71.          } 
72.        } 
73.        public static void main(String[] args) { 
74.          SwingThreadTest3 fg = new SwingThreadTest3(); 
75.          fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
76.          fg.setSize(300, 100); 
77.          fg.setVisible(true); 
78.        } 
79. } 

解释：SwingUtilities.invokeLater()方法使事件派发线程上的可运行对象排队。当可运行对象排在事件派发队列的队首时，就调用其run方法。其效果是允许事件派发线程调用另一个线程中的任意一个代码块。
还有一个方法SwingUtilities.invokeAndWait()方法，它也可以使事件派发线程上的可运行对象排队。
他们的不同之处在于：SwingUtilities.invokeLater()在把可运行的对象放入队列后就返回，而SwingUtilities.invokeAndWait()一直等待知道已启动了可运行的run方法才返回。如果一个操作在另外一个操作执行之前必须从一个组件获得信息，则应使用SwingUtilities.invokeAndWait()方法