现在，我们也许能用一个线程解决在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的执行时间，并注意到标记已发生改变，计数器才会停止。
　　用内部类改善代码
　　下面说说题外话，请大家注意一下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能在未获任何特殊许可的前提下自由地访问它――而且无论如何都该尽可能地把字段变成“私有”属性，以防来自类外的某种力量不慎地改变它们。
　　无论在什么时候，只要注意到类相互之间结合得比较紧密，就可考虑利用内部类来改善代码的编写与维护。