Java线程实现的两种方式解析

/*注意在构造器中启动这个线程的话，很容易造成this逃逸的问题，这是要注意的
* 这是通过直接集成thread来成为线程。同时在这种情况下，你可以通过调用合适的方法来
* 给thread对象赋予具体的名称。*/
public class SimpleThread extends  Thread {
    private int countDown=5;
    private static int threadCount=0;
    public SimpleThread() {
        super(Integer.toString(++threadCount));//这是给这个thread赋予名字。
        start();
    }
    public String toString(){
        return "#"+getName()+"("+countDown+"), ";
    }
    public void run() {
        while (true) {
            System.out.print(this);
            if (--countDown == 0) {
                return;
            }
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new SimpleThread();
        }
    }
}

//注意，Start()是在构造器中调用的。这个实例相当的简单，因此可能是安全的。但是应该注意到
//在构造器重启动线程可能会变得很有问题。因为另外一个任务可能会在构造器结束以前就开始执行了
//这意味着该任务能够访问处于不稳定状态的对象。这是优选Executor而不是显式地创建Thread对象的
//另外一个很重要的原因。
public class SelfManaged implements  Runnable {
    private int countDown=5;
    private Thread t = new Thread(this);
    public SelfManaged() {
        t.start();
    }
    public String toString(){
        return  Thread.currentThread().getName()+"("+countDown+")";
    }
    @Override
    public void run() {
        while (true) {
            System.out.println(this);
            if (--countDown == 0) {
                return;
            }
        }
    }
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new SelfManaged();
        }
    }
}

Thread-0(5)
Thread-2(5)
Thread-1(5)
Thread-1(4)
Thread-2(4)
Thread-2(3)
Thread-2(2)
Thread-2(1)
Thread-0(4)
Thread-0(3)
Thread-0(2)
Thread-0(1)
Thread-3(5)
Thread-1(3)
Thread-3(4)
Thread-4(5)
Thread-4(4)
Thread-4(3)
Thread-4(2)
Thread-4(1)
Thread-1(2)
Thread-1(1)
Thread-3(3)
Thread-3(2)
Thread-3(1)

public class SimplePriorities implements  Runnable {
    private int countDown=5;
    private volatile  double d;
    private int priority;
    public SimplePriorities(int priority) {
        this.priority=priority;
    }
    public String toString(){
        return Thread.currentThread()+":"+countDown;
    }
    @Override
    public void run() {
        Thread.currentThread().setPriority(priority);//为这个线程设置优先级。
        while (true) {
            for (int i = 0; i < 10000; i++) {
                d += (Math.PI + Math.E)/(double)i;
                if (i / 1000 == 0) {
                    Thread.yield();
                }
            }
            System.out.println(this);
            if (--countDown == 0) {
                return;
            }
        }
    }
    public static void main(String[] args) {
        ExecutorService exec= Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++) {
            exec.execute(new SimplePriorities(Thread.MAX_PRIORITY));
            exec.execute(new SimplePriorities(Thread.MIN_PRIORITY));
            exec.shutdown();
        }
    }
}

class MyThread extends Thread{  
    private int ticket=10;  
    public void run(){  
        for(int i=0;i<20;i++){  
            if(this.ticket>0){  
                System.out.println("卖票：ticket"+this.ticket--);  
            }  
        }  
    }  
}; 

package org.demo.dff;  
    public class ThreadTicket {  
    public static void main(String[] args) {  
        MyThread mt1=new MyThread();  
        MyThread mt2=new MyThread();  
        MyThread mt3=new MyThread();  
        mt1.start();//每个线程都各卖了10张，共卖了30张票  
        mt2.start();//但实际只有10张票，每个线程都卖自己的票  
        mt3.start();//没有达到资源共享  
        }  
    } 

 package org.demo.runnable;  
 class MyThread implements Runnable{  
    private int ticket=10;  
    public void run(){  
        for(int i=0;i<20;i++){  
            if(this.ticket>0){  
            System.out.println("卖票：ticket"+this.ticket--);  
                 }  
         }  
    }  
 }  
 package org.demo.runnable;  
 public class RunnableTicket {  
    public static void main(String[] args) {  
        MyThread mt=new MyThread();  
         new Thread(mt).start();//同一个mt，但是在Thread中就不可以，如果用同一  
         new Thread(mt).start();//个实例化对象mt，就会出现异常  
         new Thread(mt).start();  
        }  
    };