首页 > 其他分享 >（转）Swing 线程之SwingUtilities.invokeLater()

（转）Swing 线程之SwingUtilities.invokeLater()

时间：2023-07-21 17:03:36浏览次数：34  
标签：invokeLater SwingUtilities void private 线程 import new public



 

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

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

需要实现的功能是：

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

 

代码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. false);  
21.         add(text);  
22.         add(start);  
23.         add(end);  
24. new Start());  
25. new End());  
26.     }  
27.           
28. private void go() {  
29. while (count < 100) {  
30. try {  
31. 100);//这里比作要完成的某个耗时的工作  
32. catch (InterruptedException e) {  
33.                 e.printStackTrace();  
34.             }  
35. //更新进度条和输入框  
36. if (flag) {  
37.                 count++;  
38.                 progressBar.setValue(count);  
39. "%");  
40.             }  
41.         }  
42.     }  
43. private class Start implements ActionListener {  
44. public void actionPerformed(ActionEvent e) {  
45. true;//设置开始更新的标志  
46. //开始工作  
47.         }  
48.     }  
49. private class End implements ActionListener {  
50. public void actionPerformed(ActionEvent e) {  
51. false;//停止  
52.         }  
53.     }  
54. public static void main(String[] args) {  
55. new SwingThreadTest1();  
56.         fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
57. 300, 100);  
58. 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：

     



      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. null;  
19. public SwingThreadTest2() {  
20. this.setLayout(new FlowLayout());  
21.         add(progressBar);  
22. false);  
23.         add(text);  
24.         add(start);  
25.         add(end);  
26. new Start());  
27. new End());  
28.     }  
29. private void go() {  
30. while (count < 100) {  
31. try {  
32. 100);  
33. catch (InterruptedException e) {  
34.                 e.printStackTrace();  
35.             }  
36. if (flag) {  
37.                 count++;  
38.                 System.out.println(count);  
39.                 progressBar.setValue(count);  
40. "%");  
41.             }  
42.         }  
43.     }  
44. private class Start implements ActionListener {  
45. public void actionPerformed(ActionEvent e) {  
46. true;  
47. if(t == null){  
48. 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. false;  
63.         }  
64.     }  
65. public static void main(String[] args) {  
66. new SwingThreadTest2();  
67.         fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
68. 300, 100);  
69. 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. false);  
26.         add(text);  
27.         add(start);  
28.         add(end);  
29. new Start());  
30. new End());  
31. 
32. new Runnable(){//实例化更新组件的线程  
33. public void run() {  
34.                 progressBar.setValue(count);  
35. "%");  
36.             }  
37.         };  
38.     }  
39. private void go() {  
40. while (count < 100) {  
41. try {  
42. 100);  
43. catch (InterruptedException e) {  
44.                 e.printStackTrace();  
45.             }  
46. if (flag) {  
47.                 count++;  
48. //将对象排到事件派发线程的队列中  
49.             }  
50.         }  
51.     }  
52. private class Start implements ActionListener {  
53. public void actionPerformed(ActionEvent e) {  
54. true;  
55. if(t == null){  
56. 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. false;  
71.         }  
72.     }  
73. public static void main(String[] args) {  
74. new SwingThreadTest3();  
75.         fg.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
76. 300, 100);  
77. true);  
78.     }  
79. }



         

         

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

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

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

         

         

         

         

        标签：invokeLater,SwingUtilities,void,private,线程,import,new,public
        From： https://blog.51cto.com/u_16200746/6803350

        相关文章

        • java线程池线程销毁
          Java线程池线程销毁指南作为一名经验丰富的开发者，我将为你展示如何实现Java线程池线程的销毁。在本文中，我将首先介绍线程池的工作原理和流程，然后逐步引导你完成这个任务。线程池工作原理Java线程池是一种管理和复用线程的机制，可以避免频繁地创建和销毁线程，提高应用程序的性能和......
        • java线程超时处理
          Java线程超时处理引言在Java中，线程是一种轻量级的执行单元，用于并发执行代码。在某些情况下，我们可能希望设置一个超时时间来控制线程的执行时间，以避免长时间的阻塞或无限期的等待。本文将介绍如何在Java中处理线程超时的方法，并提供相应的代码示例。方法一：使用Thread.join(longti......
        • iOS 多线程自己的理解
          .创建线程的平均开销:内存堆栈:主线程——1M，子线程——512K时间:基本可以忽略不计a.不可改变的对象，通常是线程安全的b.主线程负责处理响应事件线程安全的类和函数:NSArray,NSData,NSNumber.....非线程安全:NSBundle,NSCoder,NSArchiver......
        • linux 怎么看java程序有没有线程锁住的情况
          在Linux上，我们可以使用一些工具和技术来查看Java程序是否存在线程锁住的情况。下面将介绍两种常用的方法：使用jstack和使用VisualVM。使用jstackjstack是Java自带的一个命令行工具，可以用来生成Java虚拟机当前时刻的线程快照。通过分析线程快照，我们可以查看线程的状态、堆栈信息等，......
        • Java线程池详解：Future的使用和实现
          提交到线程池中执行的异步任务都会返回一个任务的Future，所以这里先介绍一下Future的使用和实现。异步任务通常会被提交到线程池中去执行，但任务并非提交到线程池后就不管不顾了，在某些时刻我们希望能够取消任务，同时也希望在任务执行完成后获取到任务的执行结果。Java提供了Futur......
        • 面霸的自我修养：Java线程专题
          王有志，一个分享硬核Java技术的互金摸鱼侠加入Java人的提桶跑路群：共同富裕的Java人平时我在网上冲浪的时候，收集了不少八股文和面试文，内容虽然多，但质量上良莠不齐，主打一个不假思索的互相抄，使得很多错误内容一代代得“传承”了下来。所以，我对收集的内容做了归纳和整理，通过查阅资料......
        • 实验五 Java多线程程序设计实验总结
          Java多线程程序设计实验总结引言多线程是计算机科学中重要的概念，它允许同时执行多个任务，从而提高程序的效率和性能。在Java中，多线程被广泛应用于各种场景，例如并发编程、网络编程等。本文将通过实验五的实践经验，介绍Java多线程程序设计的基本原理和常用技巧，并提供代码示例以加深......
        • 单线程 Redis 如此快的 4 个原因
          本文翻译自国外论坛medium，原文地址：https://levelup.gitconnected.com/4-reasons-why-single-threaded-redis-is-so-fast-414e0106f921作为内存数据存储，Redis以其速度和性能而闻名，通常被用作大多数后端服务的缓存解决方案。然而，在Redis内部采用的也只是单线程的设计。为什么......
        • java 获取当前线程id
          如何实现Java获取当前线程ID1.整体流程为了获取当前线程的ID，我们需要按照以下步骤进行操作：步骤描述1获取当前线程对象2从线程对象中获取线程ID下面我们将介绍如何逐步实现这些步骤。2.获取当前线程对象要获取当前线程的ID，我们首先需要获取当前线程对象......
        • 初识线程池
          内容:  1、什么是线程池      2、线程池的优点      3、线程池原理（重点）      4、理解线程池（重点）      5、如何设置线程池 1、什么是线程池线程池（英语：threadpool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存......

        赞助商

        阅读排行

        网站主页关于我们联系我们网站地图

        本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

        Copyright © 2020-2023 IPS99 版权所有 IPS99