如何通过使用匿名内部类来将线程代码隐藏在类中

/*有时候通过使用内部类来讲线程代码隐藏在类中会很有用*/
//    使用一个私有的内部类。
class InnerThread1{
private int countDown=5;
private Inner inner;
private class Inner extends  Thread{
//        在这里可能会造成this逃逸的问题。但是由于这里比较简单，所以不会造成这个问题。
Inner(String name) {
super(name);
start();//直接使用继承的方法。
}

@Override
public void run() {
while (true) {
System.out.println(this);
if (--countDown == 0) {
return;
}
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

public String toString() {
return getName() + ": "+countDown;
}

}

public InnerThread1(String name) {
inner = new Inner(name);//创建这个内部类的一个实例。
}
}
//在构造器中创建一个内部类。
class InnerThread2{
private int countDown=5;
private Thread t;
//使用匿名内部类来进行创建。
public InnerThread2(String name) {
t = new Thread(name){
@Override
public void run() {
super.run();
while (true) {
System.out.println(this);
if (--countDown == 0) {
return;
}
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

public String toString() {
return getName() + ": "+countDown;
}
};
t.start();
}
}

//通过实现Runnable接口来实现内部的线程。实现线程的是一个内部类
class InnerRunnable1{
private int countDown=5;
private Inner inner;

private class Inner implements  Runnable{
Thread t;

Inner(String name) {
t = new Thread(this, name);//name指代的是线程的名称。
t.start();
}
@Override
public void run() {
while (true) {
System.out.println(this);
if (--countDown == 0) {
return;
}
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public String toString() {
return t.getName() + ": "+countDown;
}

}

public InnerRunnable1(String name) {
inner = new Inner(name);
}
}

//在类的构造器中实现Runnable接口的线程。
class InnerRunnable2{
private int countDown=5;
private Thread t;

public InnerRunnable2(String name) {
t = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println(this);
if (--countDown == 0) {
return;
}
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//重写这个方法。
public String toString(){
return Thread.currentThread().getName()+": "+countDown;
}
}, name);
t.start();
}
}
//在一个方法中实现一个线程的内部类。这个可能相对来说是比较常用的。
class ThreadMethod{
private int countDown=5;
private Thread t;
private String name;

public ThreadMethod(String name) {
this.name = name;
}

public void runTask() {
if (t == null) {
t = new Thread(name){
@Override
public void run() {
while (true) {
System.out.println(this);
if (--countDown == 0) {
return;
}

try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}

}

}

public String toString(){
return getName()+": "+countDown;
}

};
t.start();
}

}
}

public class ThreadVariations {
public static void main(String[] args) {
new InnerThread1("InnerThread1");
new InnerThread2("InnerThread2");
new InnerRunnable1("InnerRunnable1");
new InnerRunnable2("InnerRunnable2");
new ThreadMethod("ThreadMethod").runTask();

}

}
程序运行的结果如下：
InnerThread1: 5
InnerThread2: 5
InnerRunnable1: 5
InnerRunnable2: 5
ThreadMethod: 5
InnerThread2: 4
InnerThread1: 4
InnerRunnable1: 4
InnerRunnable2: 4
ThreadMethod: 4
InnerThread1: 3
InnerThread2: 3
InnerRunnable1: 3
InnerRunnable2: 3
ThreadMethod: 3
InnerThread2: 2
InnerThread1: 2
InnerRunnable1: 2
InnerRunnable2: 2
ThreadMethod: 2
InnerThread2: 1
InnerThread1: 1
InnerRunnable1: 1
InnerRunnable2: 1
ThreadMethod: 1