Question

现在，我们也许能用一个线程解决在 Counter1.java 中出现的问题。采用的一个技巧便是在一个线程的 run() 方法中放置“子任务”——亦即位于 go() 内的循环。一旦用户按下 Start 按钮，线程就会启动，但马上结束线程的创建。这样一来，尽管线程仍在运行，但程序的主要工作却能得以继续（等候并响应用户界面的事件）。下面是具体的代码：

//: Counter2.java
// A responsive user interface with threads
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

class SeparateSubTask extends Thread {
  private int count = 0;
  private Counter2 c2;
  private boolean runFlag = true;
  public SeparateSubTask(Counter2 c2) {
    this.c2 = c2;
    start();
  }
  public void invertFlag() { runFlag = !runFlag;}
  public void run() {
    while (true) {
     try {
      sleep(100);
     } catch (InterruptedException e){}
     if(runFlag) 
       c2.t.setText(Integer.toString(count++));
    }
  }
} 

public class Counter2 extends Applet {
  TextField t = new TextField(10);
  private SeparateSubTask sp = null;
  private Button 
    onOff = new Button("Toggle"),
    start = new Button("Start");
  public void init() {
    add(t);
    start.addActionListener(new StartL());
    add(start);
    onOff.addActionListener(new OnOffL());
    add(onOff);
  }
  class StartL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      if(sp == null)
        sp = new SeparateSubTask(Counter2.this);
    }
  }
  class OnOffL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      if(sp != null)
        sp.invertFlag();
    }
  }
  public static void main(String[] args) {
    Counter2 applet = new Counter2();
    Frame aFrame = new Frame("Counter2");
    aFrame.addWindowListener(
      new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
          System.exit(0);
        }
      });
    aFrame.add(applet, BorderLayout.CENTER);
    aFrame.setSize(300,200);
    applet.init();
    applet.start();
    aFrame.setVisible(true);
  }
} ///:~

现在，Counter2 变成了一个相当直接的程序，它的唯一任务就是设置并管理用户界面。但假若用户现在按下 Start 按钮，却不会真正调用一个方法。此时不是创建类的一个线程，而是创建 SeparateSubTask，然后继续 Counter2 事件循环。注意此时会保存 SeparateSubTask 的句柄，以便我们按下 onOff 按钮的时候，能正常地切换位于 SeparateSubTask 内部的 runFlag（运行标志）。随后那个线程便可启动（当它看到标志的时候），然后将自己中止（亦可将 SeparateSubTask 设为一个内部类来达到这一目的）。

SeparateSubTask 类是对 Thread 的一个简单扩展，它带有一个构建器（其中保存了 Counter2 句柄，然后通过调用 start() 来运行线程）以及一个 run()——本质上包含了 Counter1.java 的 go() 内的代码。由于 SeparateSubTask 知道自己容纳了指向一个 Counter2 的句柄，所以能够在需要的时候介入，并访问 Counter2 的 TestField（文本字段）。

按下 onOff 按钮，几乎立即能得到正确的响应。当然，这个响应其实并不是“立即”发生的，它毕竟和那种由“中断”驱动的系统不同。只有线程拥有 CPU 的执行时间，并注意到标记已发生改变，计数器才会停止。

1. 用内部类改善代码

下面说说题外话，请大家注意一下 SeparateSubTask 和 Counter2 类之间发生的结合行为。SeparateSubTask 同 Counter2“亲密”地结合到了一起——它必须持有指向自己“父”Counter2 对象的一个句柄，以便自己能回调和操纵它。但两个类并不是真的合并为单独一个类（尽管在下一节中，我们会讲到 Java 确实提供了合并它们的方法），因为它们各自做的是不同的事情，而且是在不同的时间创建的。但不管怎样，它们依然紧密地结合到一起（更准确地说，应该叫“联合”），所以使程序代码多少显得有些笨拙。在这种情况下，一个内部类可以显著改善代码的“可读性”和执行效率：

//: Counter2i.java
// Counter2 using an inner class for the thread
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

public class Counter2i extends Applet {
  private class SeparateSubTask extends Thread {
    int count = 0;
    boolean runFlag = true;
    SeparateSubTask() { start(); }
    public void run() {
      while (true) {
       try {
        sleep(100);
       } catch (InterruptedException e){}
       if(runFlag) 
         t.setText(Integer.toString(count++));
      }
    }
  } 
  private SeparateSubTask sp = null;
  private TextField t = new TextField(10);
  private Button 
    onOff = new Button("Toggle"),
    start = new Button("Start");
  public void init() {
    add(t);
    start.addActionListener(new StartL());
    add(start);
    onOff.addActionListener(new OnOffL());
    add(onOff);
  }
  class StartL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      if(sp == null)
        sp = new SeparateSubTask();
    }
  }
  class OnOffL implements ActionListener {
    public void actionPerformed(ActionEvent e) {
      if(sp != null)
        sp.runFlag = !sp.runFlag; // invertFlag();
    }
  }
  public static void main(String[] args) {
    Counter2i applet = new Counter2i();
    Frame aFrame = new Frame("Counter2i");
    aFrame.addWindowListener(
      new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
          System.exit(0);
        }
      });
    aFrame.add(applet, BorderLayout.CENTER);
    aFrame.setSize(300,200);
    applet.init();
    applet.start();
    aFrame.setVisible(true);
  }
} ///:~

这个 SeparateSubTask 名字不会与前例中的 SeparateSubTask 冲突——即使它们都在相同的目录里——因为它已作为一个内部类隐藏起来。大家亦可看到内部类被设为 private（私有）属性，这意味着它的字段和方法都可获得默认的访问权限（run() 除外，它必须设为 public，因为它在基础类中是公开的）。除 Counter2i 之外，其他任何方面都不可访问 private 内部类。而且由于两个类紧密结合在一起，所以很容易放宽它们之间的访问限制。在 SeparateSubTask 中，我们可看到 invertFlag() 方法已被删去，因为 Counter2i 现在可以直接访问 runFlag。

此外，注意 SeparateSubTask 的构建器已得到了简化——它现在唯一的用外就是启动线程。Counter2i 对象的句柄仍象以前那样得以捕获，但不再是通过人工传递和引用外部对象来达到这一目的，此时的内部类机制可以自动照料它。在 run() 中，可看到对 t 的访问是直接进行的，似乎它是 SeparateSubTask 的一个字段。父类中的 t 字段现在可以变成 private，因为 SeparateSubTask 能在未获任何特殊许可的前提下自由地访问它——而且无论如何都该尽可能地把字段变成“私有”属性，以防来自类外的某种力量不慎地改变它们。

无论在什么时候，只要注意到类相互之间结合得比较紧密，就可考虑利用内部类来改善代码的编写与维护。