【Swing】理解Swing中的事件与线程

talk is cheap ， show me the code.

Swing中的事件

事件驱动

所有的GUI程序都是事件驱动的。Swing当然也是。

GUI程序不同于Command Line程序，一个很大的区别是程序执行的驱动条件：命令行程序是接受用户输入的文本参数，对命令解析，然后通过类似switch的选择来执行不同的功能模块。而GUI程 序就不一样了。GUI程序由界面元素组成，如Button，CheckBox，TextArea，等等。用户操作不同的组件，就会引发不同的事件，然后， 程序编写时注册到UI组件上的事件处理程序得到调用，以此来和用户交互。

        

事件Event

事件有点类似于异常：事件是事件类的对象，它携带了事件相关的信息，异常是异常类的对象，他携带了异常信息。无论是异常，还是事件

发生时，我们的程序都要事先写好相应的代码应对并处理。只不过，对于程序员来说，事件是正派的，而异常则是反派，谁也不希望自己的程序出现异常。

java中，所有的事件类都是EventObject类的子类，所有的事件都有一个成员字段：source用来保存事件源，即引发事件的对象。

public class EventObject implements java.io.Serializable {

    private static final long serialVersionUID = 5516075349620653480L;

    /* source保存 引发事件的对象的引用*/

    protected transient Object  source;

    public EventObject(Object source) {
    if (source == null)
        throw new IllegalArgumentException("null source");

        this.source = source;
    }

    public Object getSource() {
        return source;
    }
    public String toString() {
        return getClass().getName() + "[source=" + source + "]";
    }
}

Swing的事件机制由AWT提供，下面是Swing中常用的高级事件 ActionEvnet类的部分代码。还有其他事件。

public class ActionEvent extends AWTEvent {

    public ActionEvent(Object source, int id, String command, long when,
                       int modifiers) {
        super(source, id);
        this.actionCommand = command;
        this.when = when;
        this.modifiers = modifiers;
    }
    //.......
}

事件队列Event Queue

Swing应用程序中的所有事件都会由 java.awt.EventQueue对象来管理。

1、EventQueue中的事件会按序一 一 分发，一个时间点只能处理1个事件。

2、如果时间A先入队，B后入队，则A一定会在B的前面被处理。

3、队列中的事件会在一个单独的线程中被处理，这个线程就是EDT线程。

由于Swing是单线程的，线程不安全的，所以Swing中的UI操作就必须以事件的形式放置到EventQueue中按序分发处理。这就保证了Swing组件状态的可预知性和正确性。

Swing的正确使用姿势是：所有与GUI相关的操作都必 以事件的形式发布到Event Queue中，并在EDT中处置。

事件源EventSource

异常，有引发异常的原因，事件，也有引发事件的对象，这就是事件源。谁引发了事件，谁就是事件源。

比如，Button被点击时引发事件，Button就是事件源，JFrame 状态变化时，JFrame也是事件源。Swing中所有的组件，都有感知自己被操作的能力。

Swing中，事件源一般是一些用户组件，他们能感知用户的操作，并引发相应的事件，最后通知对自己注册的监听器。

事件源都会提供事件的注册接口，所有对某个组件的某个事件感兴趣的其他代码，都可以提前注册到这个组件上，事件发生时，此组件就会调用相应的注册的

事件处理程序。

下面是JButton的父类 AbstractButton的一个方法。

protected void fireActionPerformed(ActionEvent event)
{
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        ActionEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length-2; i>=0; i-=2)
        {
            if (listeners[i]==ActionListener.class)
            {
                // Lazily create the event:
                if (e == null) {
                      String actionCommand = event.getActionCommand();
                      if(actionCommand == null)
                      {
                         actionCommand = getActionCommand();
                      }
                      e = new ActionEvent(AbstractButton.this,
                                          ActionEvent.ACTION_PERFORMED,
                                          actionCommand,
                                          event.getWhen(),
                                          event.getModifiers());
                }
                ((ActionListener)listeners[i+1]).actionPerformed(e);
            }
        }
}

监听者Listener

监听者（有的也叫侦听器）：实现了某个监听接口的类对象。某个类实现了一个监听器接口，它就是一个监听者。

当事件发生时，并不是事件源处理事件，而是注册在事件源的上的监听器去处理。事件源只是通知监听器，通知实质是调用所有监听器对象按接口约定实现的的接口方法。

我们知道，对象实现了某个接口，就代表这个对象能做什么。同理，一个对象想成为监听器，它就必须实现相应的监听器接口，表明他有处理某个事件的能力。

监听器实现了监听接口，就必然要实现接口中定义的方法，用来应对事件。

所有的监听器接口都必须扩展自EventListener,它是一个空接口。一个事件往往对应一个监听者接口。

JComponnet类是所有Swing组件的父类。JComponnet 类中有一个 EventListenerList成员，它是一个表，用来存储所有注册的监听者。那也就是说，所有的Swing组件内部都包含一个存储监听者的列表，这也是为什么能向Swing组件中注册监听器的本质。

public abstract class JComponent extends Container implements Serializable,TransferHandler.HasGetTransferHandler{
    /** A list of event listeners for this component. */
    protected EventListenerList listenerList = new EventListenerList();
   //.......
}    

/**   EventListenerList类
   这是一个用于保存监听器的一个表类型。这个表可以存储任何类型的EventListener，因为内部是用的一个Object数组存储的。
 */
public class EventListenerList implements Serializable
{
    protected transient Object[] listenerList = NULL_ARRAY;
    //获取所有监听者的数组
    public Object[] getListenerList()
    {
        return listenerList;
    }
     /**
     * 返回监听者的数量*/
    public int getListenerCount()
    {
        return listenerList.length/2;
    }

    /**
       向监听者列表中添加 “一对” 新的监听者。其实是添加一个监听者，
       只不过对于一个监听者需要保存2项：监听者的类  t，和监听者本身 l
     */
    public synchronized <T extends EventListener> void add(Class<T> t, T l)
    {
        if (l==null) {return;}

        if (!t.isInstance(l))
        {   throw new IllegalArgumentException("Listener " + l +" is not of type " + t);  }

        if (listenerList == NULL_ARRAY)
        {
            //如果是第一次添加监听者，则 new 一个Object 数组。
            listenerList = new Object[] { t, l };
        }
        else
        {

            int i = listenerList.length;
            Object[] tmp = new Object[i+2];
            System.arraycopy(listenerList, 0, tmp, 0, i);

            tmp[i] = t;
            tmp[i+1] = l;

            listenerList = tmp;
        }
    }

}

这个时候你再回去看事件源分块中的那段代码，是不是思路清晰许多了呢？

所以，事件源通知监听者，实质是遍历内部的监听者表，将自己作为EventSorece，构造一个事件对象，并调用所有监听者的事件处理程序时，将构造的事件对象传递过去。

如果你还是有点迷糊，下面通过一例子说明下。

下面是一个简单的Swing程序。

监听者：ButtonClickListener 类对象，它实现了监听器接口。一般我们会使用匿名内部类完成监听者的实例化，这里写出成员内部类是为了更清晰。当使用addActionListener方法注册后，ButtonClickListener对象就被存储在Button对象内部的一个EventListenerList列表中了。

事件   ：点击Button时生成。

事件源：被点击的Button对象。

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;

public class SwingDrive {

    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                JFrame frame = new TestFrame("测试");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);

            }
        });
    }

}

class TestFrame extends JFrame
{

    private static final int FRAME_WIDTH = 530;
    private static final int FRAME_HEIGHT = 360;

    /*************View******************/
    private JPanel mainPanel = null;
    private JButton msgButton = null;
    private JLabel msgLabel = null;

    public TestFrame(String title)
    {
        super(title);
        initUI();
    }

    private void initUI()
    {
        //内容面板
        mainPanel = new JPanel();
        mainPanel.setPreferredSize(new Dimension(FRAME_WIDTH,FRAME_HEIGHT));
        this.setContentPane(mainPanel);

        //按钮
        msgButton = new JButton("我是按钮");
        //监听者表示对按钮的点击事件感兴趣，于是注册到按钮上。
        msgButton.addActionListener(new ButtonClickListener());

        //msg显示文本
        msgLabel = new JLabel();

        //将组建添加到窗体的内容面板中
        this.add(msgButton);
        this.add(msgLabel);
        this.pack();

    }

    /*监听者，实现了监听接口*/
    private class ButtonClickListener implements ActionListener
    {

        @Override
        public void actionPerformed(ActionEvent e) {

            msgLabel.setText("你点击了按钮");
        }
    }
}

还有一点疑问

who invoke the fireActionPerformed(ActionEvent event)   method？

谁调用了JButton的fireActionPerformed方法呢？

如果你能想到这个问题，说明你已经开始深入了。这是Swing本身的机制，确切说是AWT提供的机制。一个Swing程序中会有一个toolkit线程不断运行着，它监视用户对组件的操作，当组件被点击，获取焦点，被最大化，状态改变等，都会被toolkit线程发现，并将fireXXX发送带EDT中执行，fireXXX的执行，又会导致所有监听器的执行。

先不急，这涉及到Swing线程的知识，请往下看。

Swing中的线程

1、主线程，main方法，程序执行的入口。任何程序都必须有的。

2、初始化线程。创建和初始化图形界面。

3、tookit线程：负责捕捉系统事件，如鼠标，键盘等。负责感知组件的操作，并将事件发通知EDT。

4、EDT线程：处理Swing中的各种事件。UI绘制，UI的修改操作,UI的绘制渲染.，监听者的事件处理函数，等。所有的UI操作都必须在EDT线程中执行，不允许在其他线程中。

5、N个后台工作线程：处理耗时任务，如网络资源下载，可能阻塞的IO操作。

初始化线程

public static void main(String [] args)
{

    SwingUtilities.invokeLater(new Runnable{

        public void run()
        {

            //初始化线程逻辑代码在这里执行
        }

    });

}

 Swing多线程的执行

图画完后，我才发现图画的有一问题：其中EDT线程和toolkit线程是循环线程，并没有确切的执行终点，也就是不知道这2个线程什么时候执行任务到100%。只要Swing程序没有结束，他们就一直工作，因为用户可能在任何时候执行UI操作。

后台工作线程当执行完任务后就结束了。

一、不要在EDT线程中执行耗时的任务。

一旦EDT线程被阻塞，UI组件就不能及时渲染，更新，使得整个程序失去对用户的响应。用户体验十分糟糕。

Swing本身是设计为单线程操作的,并非线程安全的.这就意味着:所有的UI操作都会必须在EDT线程中进行。内置的组件都是遵守这个约定的，比如一个JButton被按下时，它需要显示为按下的状态，那么，这个渲染为按下的状态，就会以事件的形式发布到EDT线程中去执行。同样，按钮弹起时，需要渲染为普通状态，也会引发事件，并在EDT中处理。

不要让EDT干 "体力活"。很明显，Swing中组件UI的更新，都会形成事件置于事件队列，并等待EDT派发，也就是UI更新依赖EDT线程完成。如果你的事件处理程序太耗时了，那么，UI就很久得不到及时更新，造成界面假死现象。

下面这个程序中，用户点击下载按钮后，真个界面都失去了响应，按钮久久不能弹起，窗口也失去了响应，体验很糟糕。

class BadFrame extends JFrame
{

    public BadFrame()
    {
        super();
        initUI();
    }

    private JButton downloadButton ;
    private JPanel  mainPane ;

    private void initUI()
    {
        mainPane =  new JPanel();
        mainPane.setPreferredSize(new Dimension(430,250));
        this.setContentPane(mainPane);

        downloadButton = new JButton("下载");
        this.getContentPane().add(downloadButton);
        downloadButton.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {

                downloadMovie();

            }
        });

        this.pack();

    }

    //模拟下载任务
    private void downloadMovie()
    {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

二、不要在非EDT线程中访问UI，操作UI组件。

Swing组件都不是线程安全的，只有把他们的操作限制在一个线程中，才能保证所有的UI的操作都符合预期。这个线程就是EDT线程。那么，怎样将UI操作发送到EDT中执行呢？

通过以下之一。

EDT线程维护一个事件队列EventQueue , 所有的UI渲染，UI事件都打包为事件放到EventQueue中排队处理。这样就让Swing在并发编程安全运行，因为单一线是顺序执行的，不会有线程安全性的问题。

 SwingUtilities.invokeLater(new Runnable() {

             @Override
             public void run() {

             }
         });9          

 SwingUtilities.invokeAndWait(new Runnable() {

             @Override
             public void run() {
                 // TODO Auto-generated method stub

             }
         });9

他们有什么区别？

SwingUtilities.invokeLater调用后立即返回。然后执行第9行后的代码。其他线程和 invokeLater中的参数线程异步执行。互不阻塞。

SwingUtilities.invokeAndWait调用后，必须等到 线程对象 run方法在EDT中执行完了，才返回，然后继续执行第9行后的代码。

下面是一个简单的例子：用户输入2个整数 start ，end，程序计算从start 累加到end 的结果。我依然使用了线程睡眠来模拟耗时任务。因为如果我使用更加贴近现实的例子的话，又会引出更多的知识点。

虽然简单，但说明了如何让Swing更好的工作。

import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

public class Demo {

    public static void main(String[] args)
    {

        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                MFrame frame = new MFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setVisible(true);

            }
        });

    }

}

class MFrame extends JFrame
{

    public MFrame()
    {
        initUI();
        onButtonClick();
    }

    /***************Model*************/
    private int start  = 0;
    private int end    = 0;
    private int result = 0;

    /************View***************/
    private JButton     calcButton  = null;
    private JTextField  startField  = null;
    private JTextField  endField    = null;
    private JTextField  resultField = null;
    private JPanel      mainpane    = null;

    private void initUI()
    {
        calcButton =new JButton("计算");

        startField = new JTextField();
        startField.setColumns(5);

        endField = new JTextField();
        endField.setColumns(5);

        resultField = new JTextField();
        resultField.setColumns(5);
        resultField.setEditable(false);

        mainpane = new JPanel(new GridLayout(1, 4,5,0));
        mainpane.setPreferredSize(new Dimension(300,50));

        mainpane.add(startField);
        mainpane.add(endField);
        mainpane.add(resultField);
        mainpane.add(calcButton);

        this.setContentPane(mainpane);
        this.setLocationRelativeTo(null);
        this.pack();

    }

    //为button注册监听者
    private void onButtonClick()
    {

        calcButton.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent event) {

                Thread calcThread = new Thread(new Runnable() {

                    @Override
                    public void run()
                    {

                        try{
                            start = Integer.parseInt(startField.getText());
                            end   = Integer.parseInt(endField.getText());

                            for (int i = start; i <=end; i++)
                            {
                                result += i;    //假设计算过程十分耗时，就像挖矿一样。

                                Thread.sleep(500);
                            }

                            //耗时任务完成后了，通过SwingUtilities.invokeLater将设置任务到UI的事件发送到EDT线程中。
                            SwingUtilities.invokeLater(new Runnable()
                            {
                                @Override
                                public void run() {
                                    resultField.setText(result+"");
                                }
                            });

                        }

                        catch(NumberFormatException e)
                        {
                            JOptionPane.showMessageDialog(MFrame.this, "请输入一个合法的整数", "错误", JOptionPane.ERROR_MESSAGE);
                        }
                        catch (InterruptedException e) {
                            System.out.println("计算时错误");
                        }

                    }
                });  //wrok Thread new End

                calcThread.start();  //启用任务线程

            }
        });

    }

}

更优雅的解决办法：SwingWorker线程类

当Swing程序复杂后，自定义线程会让代码越来越庞大，不好理解。于是jdk1.6中引入了SwingWorker线程类，简化了程序员的工作。今天就写到这里，我会在以后的文章中介绍。:)