Swing多线程

当运行一个 Swing 程序时，会自动创建三个线程。

1.主线程，负责执行main 方法。

2. toolkit 线程，负责捕捉系统事件，比如键盘、鼠标移动等，程序员不会有任何代码在这个线程上执行。Toolkit线程的作用是把自己捕获的事件传递给第三个线程，也就是事件派发线程。

3. 事件派发线程（EDT，Event Dispatcher Thread），顾名思义是用来派发事件（根据事件找到对应的事件处理代码）的线程。EDT接收来自 toolkit 线程的事件，并且将这些事件组织成一个队列，EDT的工作内容就是将这个队列中的事件按照顺序派发给相应的事件监听器，并且调用事件监听器中的回调函数，这也意味着，所有的事件处理代码都是在EDT而不是主线程中执行。

上面说到EDT中维护了一个事件的队列，并且它们是按照顺序派发的。由于事件派发是单线程的操作，所以只有等待前面事件监听器的回调函数执行完毕，才能够执行组件更新的操作，以及继续派发后面的事件。这样导致的一个后果就是：当在一个事件监听回调函数中做了耗时的操作，那么，界面会因此停住，并且界面上所有控件失效（不可触发）。

解决这个问题的方法是：在事件处理函数中将耗时的操作放到新线程（一般称之为工作线程）中执行，而不是让其在EDT中执行。比如下面的例子。

案例

一个窗口，有一个按钮和一个label。点击按钮，系统将做模仿导入数据的动作，导入数据之前需要检测数据的合法性。并且，检测数据和导入数据这两个步骤都需要耗费一定的时间。

如果没有之前说到的EDT的概念，那么你可能会这么做：

1. importBtn.addActionListener(new ActionListener() {   
2.             @Override  
3.             public void actionPerformed(ActionEvent e) {   
4.                 try {   
5.                     lb.setText(“1.检查数据合法性…”);   
6.                     Thread.sleep(3000);//模仿检测数据合法性   
7.                     lb.setText(“2.正在导入数据…”);   
8.                     Thread.sleep(4000);//模仿导入数据   
9.                     lb.setText(“3.导入成功!”);   
10.                 } catch (InterruptedException e1) {   
11.                     e1.printStackTrace();   
12.                 }   
13.             }   
14.         });   

 

但是，如果运行一下的话，会发现现象是这样：点击按钮，界面卡住，按钮变得不可触发，直到一段时间（7秒）之后界面显示“3.导入成功”。期间并没有显示“1.检查数据合法性”和“2.正在导入数据”。

这个现象印证了上面说的理论：当事件派发线程中正在执行的事件监听函数执行完毕，才能进行UI组件的刷新操作，并且派发事件队列中的下一个。

下面是修改后的代码，将耗时的操作放在一个新的工作线程中执行：

1. importBtn.addActionListener(new ActionListener() {   
2.             @Override  
3.             public void actionPerformed(ActionEvent e) {   
4.                 new Thread(new Runnable() {//开辟一个工作线程   
5.                     @Override  
6.                     public void run() {   
7.                         try {   
8.                             lb.setText(“1.检查数据合法性…”);   
9.                             Thread.sleep(3000);//模仿检测数据合法性   
10.                             lb.setText(“2.正在导入数据…”);   
11.                             Thread.sleep(4000);//模仿导入数据   
12.                             lb.setText(“3.导入成功!”);   
13.                         } catch (InterruptedException e1) {   
14.                             e1.printStackTrace();   
15.                         }   
16.                     }   
17.                 }).start();   
18.             }   
19.         });   

 

执行结果很令人满意：点击按钮，显示检查数据合法性，三秒钟之后显示正在导入数据，四秒钟之后显示导入完毕。

主题

下面到了SwingUtilities的内容。在swing编程中有一个编程原则：所有的界面相关的更新，都应该在 EDT 上执行，否则会导致界面绘制出现不稳定性错误。这也就意味着上面代码的lb.setText(“2.正在导入数据…”);应该在EDT中，而非新的工作线程中执行。这样就出现了一个矛盾：耗时的操作必须要在工作线程中执行，否则会出现界面刷新不及时和卡顿的现象，而工作线程中的界面刷新代码又会导致界面绘制的不稳定。

SwingUtilities可以解决这个矛盾。SwingUtilities的invokeLater和invokeAndWait方法可以将一个可执行对象（Runnable）实例追加到EDT的可执行队列中。那么最后的代码应该是这样的：

1. importBtn.addActionListener(new ActionListener() {   
2.             @Override  
3.             public void actionPerformed(ActionEvent e) {   
4.                 new Thread(new Runnable() {   
5.                     @Override  
6.                     public void run() {   
7.                         try {   
8.                             SwingUtilities.invokeLater(new Runnable() {   
9.                                 @Override  
10.                                 public void run() {   
11.                                     lb.setText(“1.检查数据合法性…”);   
12.                                 }   
13.                             });   
14.                             Thread.sleep(3000);//模仿检测数据合法性   
15.                             SwingUtilities.invokeLater(new Runnable() {   
16.                                 @Override  
17.                                 public void run() {   
18.                                     lb.setText(“2.正在导入数据…”);   
19.                                 }   
20.                             });   
21.                             Thread.sleep(4000);//模仿导入数据   
22.                             SwingUtilities.invokeLater(new Runnable() {   
23.                                 @Override  
24.                                 public void run() {   
25.                                     lb.setText(“3.导入成功!”);   
26.                                 }   
27.                             });   
28.                         } catch (InterruptedException e1) {   
29.                             e1.printStackTrace();   
30.                         }   
31.                     }   
32.                 }).start();   
33.             }   
34.         });   

 

关于invokeLater和invokeAndWait的区别，请自行搜索。

结论

通过上面内容可以总结以下两个swing编程原则

所有的界面相关的更新，都应该在 EDT 上执行

而耗时的后台运行，不应该在 EDT 上执行

扩展

对于java8来说上面的代码可以用lambda实现的更加优雅一些，如下：

1. importBtn.addActionListener(e -> {   
2.           new Thread(() -> {   
3.               try {   
4.                   SwingUtilities.invokeLater(() -> lb.setText(“1.检查数据合法性…”));   
5.                   Thread.sleep(3000);//模仿检测数据合法性   
6.                   SwingUtilities.invokeLater(() -> lb.setText(“2.正在导入数据…”));   
7.                   Thread.sleep(4000);//模仿导入数据   
8.                   SwingUtilities.invokeLater(() -> lb.setText(“3.导入成功!”));   
9.               } catch (InterruptedException e1) {   
10.                   e1.printStackTrace();   
11.               }   
12.           }).start();   
13.       });