Swing中的线程并发处理

理论解释见官方的文档：

https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html

一个Swing程序中一般有下面三种类型的线程：

• 初始化线程(Initial Thread)
• UI事件调度线程(EDT)
• 任务线程(Worker Thread)，可以看成后台其他的线程

每个程序必须有一个main方法，这是程序的入口。该方法运行在初始化或启动线程上。初始化线程读取程序参数并初始化一些对象。在许多Swing程序中，该线程主要目的是启动程序的图形用户界面(GUI)。一旦GUI启动后，对于大多数事件驱动的桌面程序来说，初始化线程的工作就结束了。
        Swing程序只有一个EDT线程，该线程负责GUI组件的绘制和更新，通过调用程序的事件处理器来响应用户交互。所有事件处理都是在EDT上进行的，程序同UI组件和其基本数据模型的交互只允许在EDT上进行，所有运行在EDT上的任务应该尽快完成，以便UI能及时响应用户输入。
        Swing编程时应该注意以下两点：
1.从其他线程访问UI组件及其事件处理器会导致界面更新和绘制错误。
2.在EDT上执行耗时任务会使程序失去响应，这会使GUI事件阻塞在队列中得不到处理。
3.应使用独立的任务线程来执行耗时计算或输入输出密集型任务，比如同数据库通信、访问网站资源、读写大树据量的文件。

　　从java6开始，SwingWorker类帮你管理任务线程和Swing EDT之间的交互，对于任务线程来说，就是SwingWorker执行和界面无直接关系的耗时任务和I/O密集型操作。

一个主界面启动的正确姿势：

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                MainFrame mainUI = new MainFrame();
                mainUI.showJFrame();
            }
        });

    }

　　将任务放到EDT执行的方法是SwingUtilities.invokeAndWait，不像invokeLater，invokeAndWait方法是阻塞执行的，它在EDT上执行Runnnable任务，直到任务执行完了，该方法才返回调用线程。
　　invokeLater和invokeAndWait都在事件派发队列中的所有事件都处理完之后才执行它们的Runnable任务，也就是说，这两个方法将Runnable任务放在事件队列的末尾。
　　注意：虽然可以在其他线程上调用invokeLater，也可以在EDT上调用invokeLater，但是千万不要在EDT线程上调用invokeAndWait方法！这样做会造成线程竞争，程序就会陷入死锁。那么一个好的办法是不要使用invokeAndWait方法。

一个演示阻塞和非阻塞的例子：

Factorial，用于普通阶乘计算类

package concurrency;

public class Factorial {

    private int n;

    public Factorial(int n) {
        this.n = n;
    }

    public Integer call() {
        int result = 1;

        for (int i = 1; i <= n; i++) {
            result = result * i;
        }

        try {
            Thread.sleep(5000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        System.out.println("currentThread = " + Thread.currentThread().getName());
        return result;
    }

}

一个Callable的阶乘实现类

package concurrency;

import java.util.concurrent.Callable;

public class FactorialCalculator implements Callable<Integer> {
    private int n;

    public FactorialCalculator(int n) {
        this.n = n;
    }

    public Integer call() {
        int result = 1;

        for (int i = 1; i <= n; i++) {
            result = result * i;
        }

        try {
            Thread.sleep(5000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }

        System.out.println("currentThread = " + Thread.currentThread().getName());
        return result;
    }
}

测试类

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

import javax.swing.JButton;
import javax.swing.SwingWorker;

import concurrency.Factorial;
import concurrency.FactorialCalculator;

public class DoBackground {

    public DoBackground() {
        // TODO Auto-generated constructor stub
    }

    //线程池处理，阻塞主UI
    public static void blockFutureGet() {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        Future<Integer> factorialResult = pool.submit(new FactorialCalculator(8));
        try {
            // Integer factorialValue = factorialResult.get(3,
            // TimeUnit.SECONDS);
            Integer factorialValue = factorialResult.get();
            System.out.println("Factorial Value (用FutureGet处理) = " + factorialValue);

        } catch (InterruptedException | ExecutionException ex) {
            ex.printStackTrace();
        }

        pool.shutdown();
    }

    //线程池futureTask处理，演示组塞主UI
    public static void blockFutureTaskGet() {
        ExecutorService pool = Executors.newSingleThreadExecutor();

        FactorialCalculator task = new FactorialCalculator(8);
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);

        pool.submit(futureTask);
        pool.shutdown();
        try {
            Integer factorialValue = futureTask.get();
            System.out.println("Factorial Value (用FutureTaskGet处理) = " + factorialValue);

        } catch (InterruptedException | ExecutionException ex) {
            ex.printStackTrace();
        }

    }

    //用主线程处理，阻塞
    public static void blockMainThread() {
        Factorial cal = new Factorial(8);
        System.out.println("Factorial Value (用主线程处理) = " + cal.call());
    }

    //用FutureGet + swingwork处理
    public static void swingworkConcurrency() {
        final SwingWorker worker = new SwingWorker() {

            @Override
            protected Object doInBackground() throws Exception {
                // TODO Auto-generated method stub
                ExecutorService pool = Executors.newSingleThreadExecutor();
                Future<Integer> factorialResult = pool.submit(new FactorialCalculator(8));
                try {
                    // Integer factorialValue = factorialResult.get(3,
                    // TimeUnit.SECONDS);
                    Integer factorialValue = factorialResult.get();
                    System.out.println("Factorial Value (用FutureGet + swingwork处理)  = " + factorialValue);

                } catch (InterruptedException | ExecutionException ex) {
                    ex.printStackTrace();
                }

                pool.shutdown();
                return null;
            }

        };
        worker.execute();
    }

    //用swingwork线程处理
    public static void swingworkMainThread() {
        final SwingWorker worker = new SwingWorker() {

            @Override
            protected Object doInBackground() throws Exception {
                try {
                    Factorial cal = new Factorial(8);
                    System.out.println("Factorial Value (用swingwork线程处理) = " + cal.call());

                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                return null;
            }

        };
        worker.execute();
    }

    /**
     * 用swingwork分发线程处理回调,并读写外部的变量值
     * @param jbtn，SwingWorker外部的对象
     */
    public static void swingworkCallback(JButton jbtn) {

        Integer backInteger;

        SwingWorker<Integer, Object> worker = new SwingWorker<Integer, Object>() {

            @Override
            protected Integer doInBackground() throws Exception {
                try {
                    Factorial cal = new Factorial(8);

                    return cal.call();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                return null;
            }

            @Override
            public void done() {
                try {
                    System.out.println("Factorial Value (用swingwork分发线程处理回调) = " + get());
                    //backInteger = (Integer) get();
                    setTitle(jbtn,get().toString());
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        };
        worker.execute();
    }

    static void setTitle(JButton jbtn,String text){

        jbtn.setText(text);
    }

}

结论：用后两种方法就已经能够实现非阻塞的设计了，即没必要自己再新建线程，或开线程池，请把一切交给swingwork去处理。

最后一个例子演示了回调如何和swing的其他对象（比如说一个jbutton进行数据读写，这是跨线程的操作，swingwork也支持的非常好）。

运行结果：