線程的生命週期

先來看看線程的幾個方法：

package thread.basics;

public class Test_Sleep_Yield_Join {
    public static void main(String[] args) {
        //sleep意思就是睡眠，當前線程暫停一段時間讓其餘線程去執行，時間到了自動復活
//        testSleep();
        //yield的意思是當前線程讓出一下cpu，後面大家能不能搶到，我無論，也有可能被當前線程繼續搶佔（實際運用中基本用不到）
//        testYield();
        //join的意思就是當前線程調用其餘線程的jion，會先執行其餘線程，直到其餘線程執行完畢，才繼續執行當前線程
        testJoin();
    }

    /**
     * @Author liuyi
     * @Description sleep意思就是睡眠，當前線程暫停一段時間讓其餘線程去執行，時間到了自動復活。
     * @Date 22:29 2020/5/23
     * @Param []
     * @return void
     **/
    static void testSleep() {
        new Thread(()->{
            for(int i=0; i<100; i++) {
                System.out.println("A" + i);
                try {
                    Thread.sleep(500);
                    //TimeUnit.Milliseconds.sleep(500)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    /**
     * @Author liuyi
     * @Description
     * @Date 22:31 2020/5/23
     * @Param []
     * @return void
     **/
    static void testYield() {
        new Thread(()->{
            for(int i=0; i<100; i++) {
                System.out.println("A" + i);
                if(i%10 == 0) Thread.yield();


            }
        }).start();

        new Thread(()->{
            for(int i=0; i<100; i++) {
                System.out.println("------------B" + i);
                if(i%10 == 0) Thread.yield();
            }
        }).start();
    }

    static void testJoin() {
        Thread t1 = new Thread(()->{
            for(int i=0; i<10; i++) {
                System.out.println("A" + i);
                try {
                    Thread.sleep(500);
                    //TimeUnit.Milliseconds.sleep(500)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(()->{

            try {
                t1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            for(int i=0; i<10; i++) {
                System.out.println("B" + i);
                try {
                    Thread.sleep(500);
                    //TimeUnit.Milliseconds.sleep(500)
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
    }
}

線程的生命週期（下圖爲馬士兵老師畫的）：

　　

常見的線程狀態有六種：

1，新建狀態：當咱們new一個線程，尚未調用start()方法的時候叫新建狀態。

2，Ready就緒狀態：當調用start方法以後，線程會被線程調度器來執行，可是一般線程並不能立刻執行，由於系統中還有其餘線程共同搶佔系統的資源，只有搶到了，才能進入Running運行狀態，因此在這期間被稱之爲就緒狀態。

3，Running運行狀態：線程處於就緒狀態，此時若是搶到系統資源就會進入Running運行狀態，直到線程正常結束或者異常中斷。

4，Teminated結束狀態：若是順利執行玩線程，就會進入Teminated結束狀態，此時線程不能回到之前的任意狀態。

5，TimedWaiting等待和Waiting等待：TimedWaiting等待指按照時間等待進入Ready就緒狀態，時間到了自動回到Running運行狀態。Waiting等待經過好比join方法讓線程進入Ready就緒狀態，須要手動調用方法好比notify()等方法進行喚醒，回到Running運行狀態。

6，Blocked阻塞：在同步代碼塊的狀況下沒獲得鎖就會處於阻塞狀態，得到鎖以後就進入Running運行狀態。