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

/*有时候通过使用内部类来讲线程代码隐藏在类中会很有用*/
//    使用一个私有的内部类。
    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