執行緒的幾種狀態

在Java當中，執行緒通常都有五種狀態，建立、就緒、執行、阻塞和死亡。

• 第一是建立狀態。在生成執行緒物件，並沒有呼叫該物件的start方法，這是執行緒處於建立狀態。

• 第二是就緒狀態。當呼叫了執行緒物件的start方法之後，該執行緒就進入了就緒狀態，
  但是此時執行緒排程程式還沒有把該執行緒設定為當前執行緒，此時處於就緒狀態。線上程執行之後，從等待或者睡眠中回來之後，也會處於就緒狀態。

• 第三是執行狀態。執行緒排程程式將處於就緒狀態的執行緒設定為當前執行緒，此時執行緒就進入了執行狀態，開始執行run函式當中的程式碼。

• 第四是阻塞狀態。執行緒正在執行的時候，被暫停，通常是為了等待某個時間的發生(比如說某項資源就緒)之後再繼續執行。
  sleep,suspend，wait等方法都可以導致執行緒阻塞。

• 第五是死亡狀態。如果一個執行緒的run方法執行結束或者呼叫stop方法後，該執行緒就會死亡。
  對於已經死亡的執行緒，無法再使用start方法令其進入就緒。

操作執行緒的基本函式

wait()

當一個執行緒執行到wait()時, 他會進入到一個和該物件相關的等待池中,同時失去了物件的鎖機制,使得其他執行緒可以訪問.
使用者可以使用notify或notifyAll來喚醒當前等待池中的執行緒

Note:wait()和notify(),notifyAll()必須放在Synchronized Block中,否則會丟擲異常

notify()會隨機喚醒一個,一般使用notifyAll()就可以

/**
 * Created by yangtianrui on 17-1-1.
 * 執行緒的wait, sleep, join, yield方法
 */
public class WaitAndNotifyDemo {

    // 用於等待喚醒的物件
    private final static Object sLockObject = new Object();

    public static void main(String[] args) {
        waitAndNotifyAll();
    }


    private static void waitAndNotifyAll
 
() {
        System.out.println("主執行緒執行");
        Thread thread = new WaitThread();
        thread.start();
        long startTime = System.currentTimeMillis();
        try {
            synchronized (sLockObject) {
                System.out.println("主執行緒等待");
                sLockObject.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long deltaTime = System.currentTimeMillis();
        System.out.println("主執行緒等待了 " + (deltaTime - startTime));
    }

    private static class WaitThread extends Thread {
        @Override
        public void run() {
            try {
                synchronized (sLockObject) {
                    Thread.sleep(3000);
                    // 釋放當前鎖
                    // 或者使用notifyAll();
                    sLockObject.notify();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


/*
    主執行緒執行
    主執行緒等待
    主執行緒等待了 3000
*/

sleep()

該函式是sleep的靜態函式,作用是使呼叫執行緒進入睡眠狀態,因此他不能改變物件的鎖機制,所以當一個Synchronized塊中呼叫sleep(),
並不會使使當前執行緒釋放掉這個鎖,即使睡眠也持有這個物件鎖

join()

等待目標執行緒執行完成後再繼續執行

/**
 * Created by yangtianrui on 17-1-1.
 * Join() 阻塞當前呼叫Join()函式所在的執行緒,直到接收執行緒執行完畢後在執行
 */
public class JoinDemo {

    public static void main(String[] args) {
        Thread thread1 = new WorkerThread("worker-1");
        Thread thread2 = new WorkerThread("worker-2");
        thread1.start();
        System.out.println("啟動執行緒1");
        try {
            // worker1 的join函式後,主執行緒會一直阻塞到thread1執行完畢
            thread1.join();
            System.out.println("啟動執行緒2");
            thread2.start();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("主執行緒繼續執行");
    }


    private static class WorkerThread extends Thread {
        public WorkerThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("work in  " + getName());
        }
    }
}

/*
    啟動執行緒1
    work in  worker-1
    啟動執行緒2
    work in  worker-2
    主執行緒繼續執行
*/

yield()

執行緒禮讓,目標執行緒由執行狀態轉換成就緒狀態,也就是讓出執行許可權,讓其他執行緒得以優先執行,但其他執行緒能否優先執行是未知的.

Note: 讓出執行時間並不是讓出持有的物件鎖

/**
 * Created by yangtianrui on 17-1-1.
 * yield()使該函式所在的執行緒讓出執行時間給其他已經就緒的執行緒
 * <p>
 * 讓出執行時間並不是讓出持有的物件鎖
 */

public class YieldDemo {


    public static void main(String[] args) {
        Thread thread1 = new YieldThread("thread-1");
        Thread thread2 = new YieldThread("thread-2");

        thread1.start();
        thread2.start();
    }


    private static class YieldThread extends Thread {
        public YieldThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                System.out.println(getName() + " priority=" + getPriority() + " i=" + i);
                // 每兩次,執行一次yield()
                if (i % 2 == 0) {
                    Thread.yield();
                }
            }
        }
    }
}
/*
    到偶數時,會切換一次執行緒
    thread-1 priority=5 i=0
    thread-2 priority=5 i=0
    thread-1 priority=5 i=1
    thread-1 priority=5 i=2
    thread-2 priority=5 i=1
    thread-1 priority=5 i=3
    thread-2 priority=5 i=2
    thread-1 priority=5 i=4
    thread-2 priority=5 i=3
    thread-2 priority=5 i=4
    thread-1 priority=5 i=5
    thread-1 priority=5 i=6
    thread-2 priority=5 i=5
    thread-2 priority=5 i=6
    thread-1 priority=5 i=7
 */

Note: yield()呼叫之後,其他執行緒並不一定會搶佔到 執行時間