執行緒的狀態

1. 執行緒建立後，呼叫start()開始執行，進入執行狀態；
2. 執行wait()方法後，進入等待狀態；
3. 進入等待狀態的執行緒需要其他執行緒通知才能返回執行狀態；
4. 如果是超時等待狀態，超時後會返回執行狀態；
5. 呼叫同步方式，沒有獲得鎖（synchronized），則進入阻塞狀態；
6. 如果是鎖是Lock介面的，則進入等待狀態；
7. 執行Runnable的run()後，進入終止狀態；

啟動 & 終止

構造執行緒

private void init(String name,ThreadGroup g,Runnable target){
    if(name == null){ 
        throw new NullPointerException("name cannot be null")
    }
    //當前執行緒為父執行緒
    Thread parent = currentThread(); 
    this.group = g;
    this.daemon = parent.isDaemon();
    this.priority = parent.getPriority();
    this
 
.name = name.toCharArray();
    this.target = target;
    setPriority(priority);
    //複製父執行緒的InheritableThreadLocal
    if(parent.inheritableThreadLocals != null){
        this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
    }
    //分配執行緒ID
    tid = nextThreadID(); 
}
 

啟動執行緒：呼叫start()方法即可啟動執行緒

終止執行緒

public static void main(String[] args)throws Exception{
    Runner one = new Runner();
    Thread countThread = new Thread(one,"CountThread");
    countThread.start();
    TimeUnit.SECONDS.sleep(1); //睡眠1秒，main執行緒對CountThread進行中斷，使countThread能夠感知中斷而結束
    countThread.interrupt();

    Runner two = new Runner();
    countThread = new Thread(two,"CountThread");
    countThread.start();
    TimeUnit.SECONDS.sleep(1); //睡眠1秒，main執行緒Runner two進行cancel，使countThread能夠感知on為false而結束
    two.cancel();
}

private static class Runner implements Runnable{
    private long i;
    private volatile boolean on = true;
    @Override
    public void run(){
        while(on && !Thread.currentThread().isInterrupted()){
            i++;
        }
        System.out.println("Count i = " + i);
    }
    public void cancel(){
        on = false;
    }
}

執行緒間通訊

等待 / 通知 機制

static boolean flag = true;
static Object lock = new Object();

public static main(String[] args)throws Exception{
    Thread waitThread = new Thread(new Wait(),"WaitThread");
    waitThread.start();
    TimeUnit.SECONDS.sleep(1);
    Thread notifyThread = new Thread(new Notify(),"NotifyThread");
    notifyThread.start();
}

static class Wait implements Runnable{
    public void run(){
        synchronized(lock){
            while(flag){
                try{
                    System.out.println(Thread.currentThread() + " wait");
                    lock.wait();
                }catch(InterruptedException e){ }
            }
            System.out.println(Thread.currentThread() + " run");
        }
    }
}

static class Notity implements Runnable{
    public void run(){
        synchronized(lock){
            System.out.println(Thread.currentThread() + " notify");
            lock.notifyAll();
            flag = false;
            SleepUtils.senond(5);
        }
        synchronized(lock){
            System.out.println(Thread.currentThread() + " hold lock again");
        }
    }
}

管道輸入 / 輸出流

public static void main(String[] args)throws Exception{
    PipedWriter out = new PipedWriter();
    PipedReader in = new PipedReader();
    out.connect(in);
    Thread printThread = new Thread(new Print(in),"PrintThread");
    printThread.start();

    int receive = 0;
    try{
        while((receive = System.in.read()) != -1){
            out.write(receive);
        }
    }finally{
        out.close();
    }
}

static class Print implements Runnable{
    private PipedReader in;
    public Print(PipedReader in){
        this.in = in;
    }
    public void run(){
        int receive = 0;
        try{
            while((receive = in.read) != -1){
                System.out.print((char)receive);
            }
        }catch(IOException e){ }
    }
}

Thread.join()

執行緒A執行thread.join()：執行緒A等待thread執行緒終止後才從thread.join()返回

public static void main(String[] args)throws Exception{
    Thread previous = Thread.currentThread();
    for(int i = 0; i < 10; i++){
        Thread thread = new Thread(new Domino(previous),String.valueOf(i));
        thread.start();
        previous = thread;
    }
    TimeUnit.SECONDS.sleep(5);
    System.out.println(Thread.currentThread().getName() + " terminate.");
}

static class Domino implements Runnable{
    private Thread thread;
    public Domino(Thread thread){
        this.thread = thread;
    }
    public void run(){
        try{
            thread.join();
        }catch(InterruptedException e){ }
        System.out.println(Thread.currentThread().getName() + " terminate.");
    }
}

ThreadLocal

public class Profiler{
    private static final ThreadLocal<long> TIME_THREADLOCAL = new ThreadLocal<long>(){
        protected Long initialValue(){
            return System.currentTimeMillis();
        }
    }

    public static final void begin(){
        TIME_THREADLOCAL.set(System.currentTimeMillis());
    }

    public static final long end(){
        return System.currentTimeMillis() - TIME_THREADLOCAL.get();
    }

    public static void main(String[] args)throws Exception{
        Profiler.begin();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("Cost: " + Profiler.end() + " mills");
    }
}

小結

執行緒的生命週期中有6中不同狀態，指定時刻，只能處在一個狀態；

執行緒的相互配合需要執行緒間的通訊，等待/通知機制可以得到生產者消費者的效果，管道輸入輸出流可以線上程間進行資料傳輸，Thread.join()有等待插入執行緒完成的效果，ThreadLocal是附帶線上程上的變數，可以讓執行緒儲存檢視值