Swing 线程之SwingUtilities.invokeLater()

转载 2013年12月05日 13:24:17

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

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

需要实现的功能是:

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

 

代码1:

  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(300100);  
  58.         fg.setVisible(true);  
  59.     }  
  60. }  

 

运行代码发现,

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

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

progressBar.setValue(count);

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

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

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

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

 

 

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


代码2:

  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(300100);  
  69.         fg.setVisible(true);  
  70.     }  
  71. }  

 

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

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

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

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

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

 

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

 

代码3:

  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(300100);  
  77.         fg.setVisible(true);  
  78.     }  
  79. }  

 

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

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

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

本文转自:http://blog.csdn.net/bzwm/article/details/3895381

Java实用经验总结--Swing篇二

转载来源:http://blog.csdn.net/kabini/article/details/1733552 1.   让JEditorPane显示细线表格 1.1. 无效的边框设置法...

SH配置中,hibernate不会自动释放session conn程序卡死

在实际应用过程中,发现一个问题,其表现形式为: 在访问数据库时,在多次(8)访问过后就出现容器不在继续访问。 有点像挂起。   研究发现,没有配置OpenSessionInVi...

Swing 线程之SwingUtilities.invokeLater()

转载自:@bzwm   http://blog.csdn.net/bzwm/article/details/3895381 现在我们要做一个简单的界面。 包括一个进度条、一个输入框、开始和...

Swing事件分发线程EDT与SwingUtilities.invokeLater

【Java线程】Swing事件分发线程EDT与SwingUtilities.invokeLater           在Swing程序中,经常能看到如下这种代码: ...

Java Swing GUI多线程之SwingUtilities.invokeLater和invokeAndWait【解决SWING界面卡住情况】

在Java中Swing是线程不安全的,是单线程的设计,这样的造成结果就是:只能从事件派发线程访问将要在屏幕上绘制的Swing组件。事件派发线程是调用paint和update等回调方法的线程,它还是事件...

Swing事件分发线程EDT与SwingUtilities.invokeLater

在Swing程序中,经常能看到如下这种代码: SwingUtilities.invokeLater(new Runnable(){     @Override       p...

【Java线程】Swing事件分发线程EDT与SwingUtilities.invokeLater

在Swing程序中,经常能看到如下这种代码: SwingUtilities.invokeLater(new Runnable(){ @Override public void run()...

Java-Swing: SwingUtilities中invokeLater和invokeAndWait介绍

事件派发线程(eventdispath thread),它是用于swing组件的,是界面的主线程。由于Swing是线程不安全的,是单线程设计,程序中对界面的操作都必须放到时间派发线程中执行。当你在ma...
  • eliteit
  • eliteit
  • 2014年05月14日 10:40
  • 461

swing线程机制&invokeLater&invokeAndWait

Swing线程机制 首先swing是单线程的,这个是这篇文章的前提,也是意义所在,当swing界面程序启动的时候,会启动3个进程, 1、主线程 2、系统工具包线程:负责捕获操作系统事件,然后将事...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Swing 线程之SwingUtilities.invokeLater()
举报原因:
原因补充:

(最多只允许输入30个字)