/* hello main
hello thread!
hello thread!
hello main
hello main
hello thread!
hello thread!
hello main */

現在兩個(gè)線(xiàn)程，都是打印一條，就休眠 1s
當1s 時(shí)間到了之后，系統先喚醒誰(shuí)呢？
看起來(lái)這個(gè)順序不是完全確定 (隨機的)
每一輪，1s 時(shí)間到了之后，到底是先喚醒 main 還是 thread，這是不確定的 (隨機的)
操作系統來(lái)說(shuō)，內部對于線(xiàn)程之間的調度順序，在宏觀(guān)上可以認為是隨機的 (搶占式執行)
這個(gè)隨機性，會(huì )給多線(xiàn)程編程帶來(lái)很多其他的麻煩

3、Thread 類(lèi)創(chuàng )建線(xiàn)程的寫(xiě)法

寫(xiě)法一： 創(chuàng )建子類(lèi)，繼承自 Thread

寫(xiě)法二： 創(chuàng )建一個(gè)類(lèi)，實(shí)現 Runnable 接口，再創(chuàng )建 Runnable實(shí)例傳給Thread 實(shí)例

通過(guò) Runnable 來(lái)描述任務(wù)的內容
進(jìn)—步的再把描述好的任務(wù)交給Thread 實(shí)例

package thread;

// Runnable 就是在描述一個(gè)任務(wù)
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("hello");
    }
}

public class demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
    }
}

寫(xiě)法三 / 寫(xiě)法四： 就是上面兩個(gè)寫(xiě)法的翻版，使用了匿名內部類(lèi)

創(chuàng )建了一個(gè)匿名內部類(lèi)，繼承自 Thread 類(lèi)，同時(shí)重寫(xiě)run方法，同時(shí)再new出這個(gè)匿名內部類(lèi)的實(shí)例

package thread;

public class demo4 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                System.out.println("hello thread!");
            }
        };
        t.start();
    }
}

new 的是Runnable，針對這個(gè)創(chuàng )建的匿名內部類(lèi)，同時(shí)new 出的 Runnable` 實(shí)例傳給 Thread 的構造方法

package thread;

public class demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello thread!");
            }
        });
        t.start();
    }
}

通常認為Runnable 這種寫(xiě)法更好一點(diǎn)，能夠做到讓線(xiàn)程和線(xiàn)程執行的任務(wù)，更好的進(jìn)行解耦
寫(xiě)代碼一般希望，高內聚，低耦合
Runnable 單純的只是描述了一個(gè)任務(wù)，至于這個(gè)任務(wù)是要通過(guò)一個(gè)進(jìn)程來(lái)執行，還是線(xiàn)程來(lái)執行，還是線(xiàn)程池來(lái)執行，還是協(xié)程來(lái)執行，Runnable 本身并不關(guān)心，Runnable 里面的代碼也不關(guān)心

第五種寫(xiě)法: 相當于是第四種寫(xiě)法的延伸，使用 lambda 表達式，是使用lambda 代替了 Runnable 而已

package thread;

public class demo6 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello thread！");
        });
        t.start();
    }
}

多線(xiàn)程能夠提高任務(wù)完成的效率

測試：有兩個(gè)整數變量，分別要對這倆變量自增10億次，分別使用一個(gè)線(xiàn)程，和兩個(gè)線(xiàn)程

此處不能直接這么記錄結束時(shí)間，別忘了，現 在這個(gè)求時(shí)間戳的代碼是在 main 線(xiàn)程中
main 和t1 ，t2 之間是并發(fā)執行的關(guān)系，此處t1和t2 還沒(méi)執行完呢，這里就開(kāi)始記錄結束時(shí)間了，這顯然是不準確的
正確做法應該是讓main線(xiàn)程等待 t1和 t2 跑完了，再來(lái)記錄結束時(shí)間
join 效果就是等待線(xiàn)程結束，t1.join就是讓main 線(xiàn)程等待t1 結束，t2.join讓 main 線(xiàn)程等待 t2結束

package thread;

public class demo7 {
    private static final long count = 10_0000_0000;

    public static void serial() {
        long begin = System.currentTimeMillis();
        long a = 0;
        for (int i = 0; i < count; i++) {
            a++;
        }
        long b = 0;
        for (int i = 0; i < count; i++) {
            b++;
        }
        long end = System.currentTimeMillis();
        System.out.println("消耗時(shí)間： " + (end- begin) + "ms");
    }

    public static void concurrency() throws InterruptedException {
        long begin = System.currentTimeMillis();
        Thread t1 = new Thread(() -> {
            long a = 0;
            for (int i = 0; i < count; i++) {
                a++;
            }
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            long b = 0;
            for (int i = 0; i < count; i++) {
                b++;
            }
        });
        t2.start();

        t1.join(); // 讓 main 線(xiàn)程等待 t1 結束
        t2.join(); // 讓 main 線(xiàn)程等待 t2 結束

        long end = System.currentTimeMillis();
        System.out.println("消耗時(shí)間： " + (end- begin) + "ms");
    }

    public static void main(String[] args) throws InterruptedException {
        // serial();
        concurrency();
    }
}

串行執行的時(shí)候，時(shí)間大概是600多ms (平均650左右)
兩個(gè)線(xiàn)程并發(fā)執行，時(shí)間大概是400多ms (平均450左右)
提升了接近50%
并不是說(shuō)，一個(gè)線(xiàn)程600多ms，兩個(gè)線(xiàn)程就是300多ms
這倆線(xiàn)程在底層到底是并行執行，還是并發(fā)執行，不確定，真正并行執行的時(shí)候,效率才會(huì )有顯著(zhù)提升

多線(xiàn)程特別適合于那種CPU密集型的程序，程序要進(jìn)行大量的計算，使用多線(xiàn)程就可以更充分的利用CPU的多核資源

六、Thread類(lèi)的其他的屬性和方法

1、Thread 的常見(jiàn)構造方法

Thread(String name)：這個(gè)東西是給線(xiàn)程 (thread對象) 起一個(gè)名字，起一個(gè)啥樣的名字，不影響線(xiàn)程本身的執行
僅僅只是影響到程序猿調試，可以借助一些工具看到每個(gè)線(xiàn)程以及名字，很容易在調試中對線(xiàn)程做出區分

可以使用 jconsole 來(lái)觀(guān)察線(xiàn)程的名字，jconsole是jdk自帶的一個(gè)調試工具

2、Thread 的幾個(gè)常見(jiàn)屬性

是否后臺線(xiàn)程：isDaemon()
如果線(xiàn)程是后臺線(xiàn)程，不影響進(jìn)程退出
如果線(xiàn)程不是后臺線(xiàn)程 (前臺線(xiàn)程)，就會(huì )影響到進(jìn)程退出
創(chuàng )建的 t1 和 t2 默認都是前臺的線(xiàn)程
即使 main 方法執行完畢，進(jìn)程也不能退出，得等 t1 和 t2 都執行完，整個(gè)進(jìn)程才能退出！
如果 t1 和 t2 是后臺線(xiàn)程，此時(shí)如果 main 執行完畢，整個(gè)進(jìn)程就直接退出，t1 和 t2 就被強行終止了

是否存活： isAlive()
操作系統中對應的線(xiàn)程是否正在運行
Thread t 對象的生命周期和內核中對應的線(xiàn)程，生命周期并不完全一致
創(chuàng )建出t對象之后，在調用 start 之前，系統中是沒(méi)有對應線(xiàn)程的
在run方法執行完了之后，系統中的線(xiàn)程就銷(xiāo)毀了，但是t這個(gè)對象可能還存在，通過(guò) isAlive就能判定當前系統的線(xiàn)程的運行情況
如果調用 start之后，run執行完之前，isAlive 就是返回true 。如果調用start 之前，run執行完之后，isAlive 就返回 false

ID是線(xiàn)程的唯一標識，不同線(xiàn)程不會(huì )重復
名稱(chēng)是各種調試工具用到
優(yōu)先級高的線(xiàn)程理論上來(lái)說(shuō)更容易被調度到
關(guān)于后臺線(xiàn)程，需要記住一點(diǎn)：JVM會(huì )在一個(gè)進(jìn)程的所有非后臺線(xiàn)程結束后，才會(huì )結束運行。
是否存活，即簡(jiǎn)單的理解，為 run 方法是否運行結束了

public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    System.out.println(Thread.currentThread().getName() + ": 我還活著(zhù)");
                            Thread.sleep(1 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + ": 我即將死去");
        });
        System.out.println(Thread.currentThread().getName()
                + ": ID: " + thread.getId());
        System.out.println(Thread.currentThread().getName()
                + ": 名稱(chēng): " + thread.getName());
        System.out.println(Thread.currentThread().getName()
                + ": 狀態(tài): " + thread.getState());
        System.out.println(Thread.currentThread().getName()
                + ": 優(yōu)先級: " + thread.getPriority());
        System.out.println(Thread.currentThread().getName()
                + ": 后臺線(xiàn)程: " + thread.isDaemon());
        System.out.println(Thread.currentThread().getName()
                + ": 活著(zhù): " + thread.isAlive());
        System.out.println(Thread.currentThread().getName()
                + ": 被中斷: " + thread.isInterrupted());
        thread.start();
        while (thread.isAlive()) {}
        System.out.println(Thread.currentThread().getName()
                + ": 狀態(tài): " + thread.getState());
    }
}

3、Thread中的一些重要方法

3.1、啟動(dòng)一個(gè)線(xiàn)程-start()

start() 決定了系統中是不是真的創(chuàng )建出線(xiàn)程

start 和 run 的區別：

• run() 單純的只是一個(gè)普通的方法，描述了任務(wù)的內容
• start() 則是一個(gè)特殊的方法，內部會(huì )在系統中創(chuàng )建線(xiàn)程

package thread;

public class demo1 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        // t.run();

        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

用 start() 是并發(fā)執行，而 run()循環(huán)打印 hello thread
run方法只是一個(gè)普通的方法，你在main線(xiàn)程里調用run，其實(shí)并沒(méi)有創(chuàng )建新的線(xiàn)程，這個(gè)循環(huán)仍然是在 main 線(xiàn)程中執行的
既然是在一個(gè)線(xiàn)程中執行，代碼就得從前到后的按順序運行，運行第一個(gè)循環(huán)，再運行第二個(gè)循環(huán)

for (int i = 0; i < 5; i++) {
	System.out.println("hello thread");
		try {
			Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
}

如果改成循環(huán)五次，打印五個(gè) hello thread，讓后打印 hello main

3.2、中斷一個(gè)線(xiàn)程

中斷線(xiàn)程：讓一個(gè)線(xiàn)程停下來(lái)

線(xiàn)程停下來(lái)的關(guān)鍵，是要讓線(xiàn)程對應的 run方法執行完
還有一個(gè)特殊的是 main 這個(gè)線(xiàn)程，對于main 來(lái)說(shuō)，得是main方法執行完，線(xiàn)程就完了)

如何中斷線(xiàn)程：

1、標志位
可以手動(dòng)的設置一個(gè)標志位 (自己創(chuàng )建的變量，boolean)，來(lái)控制線(xiàn)程是否要執行結束

package thread;

public class demo2 {
    private static boolean isQuit = false;

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        // 只要把這個(gè) isQuit 設為true，這個(gè)循環(huán)就退出了，進(jìn)一步的 run 就執行完了，再進(jìn)一步就是線(xiàn)程執行結束了
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        isQuit = true;
        System.out.println("終止 t 線(xiàn)程！");
    }
}

運行輸出：

hello thread
hello thread
hello thread
hello thread
hello thread
終止 t 線(xiàn)程！

在其他線(xiàn)程中控制這個(gè)標志位，就能影響到這個(gè)線(xiàn)程的結束
此處因為，多個(gè)線(xiàn)程共用同一個(gè)虛擬地址空間，因此，main 線(xiàn)程修改的 isQuit 和 t 線(xiàn)程判定的 isQuit，是同一個(gè)值

2、interrupted()
但是，isQuit 并不嚴謹，更好的做法，使用 Thread 中內置的一個(gè)標志位來(lái)進(jìn)行判定
Thread.interrupted() 這是一個(gè)靜態(tài)的方法
Thread.currentThread().isInterrupted() 這是實(shí)例方法，其中 currentThread 能夠獲取到當前線(xiàn)程的實(shí)例

package thread;

public class demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 在主線(xiàn)程中，調用 interrupt 方法，中斷這個(gè)線(xiàn)程
        // 讓 t 線(xiàn)程被中斷
        t.interrupt();
    }
}

運行此代碼，打印五次 hello thread 后，出現異常，然后繼續打印 hello thread

調用 t.interrupt() 這個(gè)方法，可能產(chǎn)生兩種情況：
1). 如果 t 線(xiàn)程是處在就緒狀態(tài)，就是設置線(xiàn)程的標志位為 true
2). 如果 t 線(xiàn)程處在阻塞狀態(tài) (sleep 休眠了)，就會(huì )觸發(fā)一個(gè) InterruptException

這個(gè)代碼絕大部分情況，都是在休眠狀態(tài)阻塞
此處的中斷，是希望能夠立即產(chǎn)生效果的
如果線(xiàn)程已經(jīng)是阻塞狀態(tài)下，此時(shí)設置標志位就不能起到及時(shí)喚醒的效果

調用這個(gè) interrupt 方法，就會(huì )讓 sleep 觸發(fā)一個(gè)異常，從而導致線(xiàn)程從阻塞狀態(tài)被喚醒
當下的代碼，一旦觸發(fā)了異常之后，就進(jìn)入了catch 語(yǔ)句，在catch 中，就單純的只是打了一個(gè)日志
printStackTrace 是打印當前出現異常位置的代碼調用棧，打完日志之后，就直接繼續運行

解決方法：

package thread;

public class demo3 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // 當前觸發(fā)異常后，立即退出循環(huán)
                    System.out.println("這個(gè)是收尾工作");
                    break;
                }
            }
        });
        t.start();

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 在主線(xiàn)程中，調用 interrupt 方法，中斷這個(gè)線(xiàn)程
        // 讓 t 線(xiàn)程被中斷
        t.interrupt();
    }
}

運行結果：

hello thread
hello thread
hello thread
hello thread
hello thread
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at thread.demo3.lambda$main$0(demo3.java:9)
	at java.lang.Thread.run(Thread.java:748)
這個(gè)是收尾工作

推薦的做法：
咱們一個(gè)代碼中的線(xiàn)程有很多個(gè)，隨時(shí)哪個(gè)線(xiàn)程都可能會(huì )終止
Thread.interrupted() 這個(gè)方法判定的標志位是Thread的static成員，一個(gè)程序中只有一個(gè)標志位
Thread.currentThread().isInterrupted()這個(gè)方法判定的標志位是 Thread的普通成員，每個(gè)示例都有自己的標志位，一般就無(wú)腦使用這個(gè)方法即可

3.3、線(xiàn)程等待-join()

多個(gè)線(xiàn)程之間，調度順序是不確定的，線(xiàn)程之間的執行是按照調度器來(lái)安排的，這個(gè)過(guò)程可以視為是 “無(wú)序，隨機”，這樣不太好，有些時(shí)候，我們需要能夠控制線(xiàn)程之間的順序

線(xiàn)程等待，就是其中一種控制線(xiàn)程執行順序的手段
此處的線(xiàn)程等待，主要是控制線(xiàn)程結束的先后順序

join()：調用 join 的時(shí)候，哪個(gè)線(xiàn)程調用的 join ，哪個(gè)線(xiàn)程就會(huì )阻塞等待，要等到對應的線(xiàn)程執行完畢為止 (對應線(xiàn)程的 run 執行完)

package thread;

public class demo4 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        // 在主線(xiàn)程中，使用等待操作，等 t 線(xiàn)程執行結束
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

首先，調用這個(gè)方法的線(xiàn)程是 main 線(xiàn)程，針對t這個(gè)線(xiàn)程對象調用的，此時(shí)就是讓 main 等待t
調用 join 之后，main 線(xiàn)程就會(huì )進(jìn)入阻塞狀態(tài) (暫時(shí)無(wú)法在cpu上執行)
代碼執行到 join` 這一行，就暫時(shí)停下了，不繼續往下執行了

那么join什么時(shí)候能繼續往下走，恢復成就緒狀態(tài)呢？
就是等到 t 線(xiàn)程執行完畢 ( t 的 run方法跑完了)
通過(guò)線(xiàn)程等待，就是在**控制讓** t先結束，main 后結束，一定程度上的干預了這兩個(gè)線(xiàn)程的執行順序
這是代碼中控制的先后順序，就像剛才寫(xiě)的自增 100 億次這個(gè)代碼，計時(shí)操作就是要在計算線(xiàn)程執行完之后再執行

但是 join 操作默認情況下，是死等，不見(jiàn)不散，這不合理
join 提供了另外一個(gè)版本，就是可以設置等待時(shí)間，最長(cháng)等待多久，如果等不到，就不等了

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

進(jìn)入 join 也會(huì )產(chǎn)生阻塞，這個(gè)阻塞不會(huì )一直持續下去，如果 10s 之內，t線(xiàn)程結束了，此時(shí) join直接返回
如果10s之后，t 仍然不結束， 此時(shí)join 也就直接返回
日常開(kāi)發(fā)中涉及到的一些 "等待” 相關(guān)的操作，一般都不會(huì )是死等，而是會(huì )有這樣的 "超時(shí)時(shí)間"

3.4、獲取當前線(xiàn)程的引用

Thread.currentThread() 就能夠獲取到當前線(xiàn)程的引用 (Thread 實(shí)例的引用)，哪個(gè)線(xiàn)程調用的這個(gè)currentThread，就獲取到的是哪個(gè)線(xiàn)程的實(shí)例

package thread;

public class demo5 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()); // Thread-0
            }
        };
        t.start();

        // 在 main 線(xiàn)程中調用的，拿到的就是 main 這個(gè)線(xiàn)程的實(shí)例
        System.out.println(Thread.currentThread().getName()); // main
    }
}

this.getName() ：對于這個(gè)代碼來(lái)，是通過(guò)繼承 Thread 的方式來(lái)創(chuàng )建線(xiàn)程
此時(shí)在 run 方法中，直接通過(guò) this，拿到的就是當前 Thread 的實(shí)例

		Thread t = new Thread(){
            @Override
            public void run() {
                System.out.println(this.getName());
            }
        };
        t.start();

此處的 this 不是指向 Thread 類(lèi)型了，而是指向 Runnable，而 Runnable 只是一個(gè)單純的任務(wù)，沒(méi)有 name 屬性的

		Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(this.getName()); // err
            }
        });
        t.start();

要想拿到線(xiàn)程的名字，只能通過(guò) Thread.currentThread()
lambda 表達式效果同 Runnable

		Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        t.start();

3.5、休眠當前線(xiàn)程

sleep 所謂的休眠到底是在干啥？
進(jìn)程：PCB＋雙向鏈表，這個(gè)說(shuō)法是針對只有一個(gè)線(xiàn)程的進(jìn)程是如此的
如果是一個(gè)進(jìn)程有多個(gè)線(xiàn)程，此時(shí)每個(gè)線(xiàn)程都有一個(gè)PCB，一個(gè)進(jìn)程對應的就是一組PCB了
PCB 上有一個(gè)字段tgroupld，這個(gè)id其實(shí)就相當于進(jìn)程的id，同一個(gè)進(jìn)程中的若干個(gè)線(xiàn)程的 tgroupld 是相同的

process control block
進(jìn)程控制塊 和 線(xiàn)程有啥關(guān)系？其實(shí) Linux內核不區分進(jìn)程和線(xiàn)程
進(jìn)程線(xiàn)程是程序猿寫(xiě)應用程序代碼，搞出來(lái)的詞，實(shí)際上 Linux內核只認PCB ！
在內核里 Linux 把線(xiàn)程稱(chēng)為輕量級進(jìn)程

操作系統調度線(xiàn)程的時(shí)候，就只是從就緒隊列中挑選合適的 PCB 到 CPU 上運行，阻塞隊列里的 PCB 就只能干等著(zhù)，當睡眠時(shí)間到了，系統就會(huì )把剛才這個(gè) PCB 從阻塞隊列挪回到就緒隊列，以上情況都是在 Linux 系統

內核中的很多工作都依賴(lài)大量的數據結構，但凡是需要管理很多數據的程序，都大量的依賴(lài)數據結構

4、線(xiàn)程的狀態(tài)

進(jìn)程有狀態(tài)：就緒，阻塞
這里的狀態(tài)就決定了系統按照啥樣的態(tài)度來(lái)調度這個(gè)進(jìn)程，這里相當于是針對一個(gè)進(jìn)程中只有一個(gè)線(xiàn)程的情況
更常見(jiàn)的情況下，一個(gè)進(jìn)程中包含了多個(gè)線(xiàn)程，所謂的狀態(tài)，其實(shí)是綁定在線(xiàn)程上
Linux 中，PCB 其實(shí)是和線(xiàn)程對應的，一個(gè)進(jìn)程對應著(zhù)一組 PCB

上面說(shuō)的 “就緒" 和 “阻塞” 都是針對系統層面上的線(xiàn)程的狀態(tài) (PCB)
在 Java 中Thread 類(lèi)中，對于線(xiàn)程的狀態(tài)，又進(jìn)—步的細化了

1、 NEW：安排了工作, 還未開(kāi)始行動(dòng)

把 Thread 對象創(chuàng )建好了，但是還沒(méi)有調用 start

public class demo6 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            
        });
        System.out.println(t.getState()); // NEW
        t.start();
    }
}

2、 TERMINATED：工作完成了

操作系統中的線(xiàn)程已經(jīng)執行完畢，銷(xiāo)毀了但是 Thread 對象還在，獲取到的狀態(tài)

public class demo6 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {

        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState()); // TERMINATED
    }
}

以上兩個(gè)狀態(tài)是 Java 內部搞出來(lái)的狀態(tài)，就和操作系統中的 PCB 里的狀態(tài)就沒(méi)啥關(guān)系

3、 RUNNABLE：可工作的，又可以分成正在工作中和即將開(kāi)始工作

就緒狀態(tài)，處于這個(gè)狀態(tài)的線(xiàn)程，就是在就緒隊列中，隨時(shí)可以被調度到 CPU 上
如果代碼中沒(méi)有進(jìn)行 sleep，也沒(méi)有進(jìn)行其他的可能導致阻塞的操作，代碼大概率是處在 Runnable 狀態(tài)的

public class demo7 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                // 這里什么都不能有
            }
        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState()); // RUNNABLE
    }
}

一直持續不斷的執行這里的循環(huán)，隨時(shí)系統想調度它上cpu都是隨時(shí)可以的

4、TIMED_WAITING：這幾個(gè)都表示排隊等著(zhù)其他事情

代碼中調用了sleep，就會(huì )進(jìn)入到 TIMED_WAITIN，意思就是當前的線(xiàn)程在一定時(shí)間之內，是阻塞的狀態(tài)

public class demo7 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        System.out.println(t.getState()); // TIMED_WAITING
    }
}

一定時(shí)間到了之后，阻塞狀態(tài)解除這種情況就是 TIMED_WAITING，也是屬于阻塞的狀態(tài)之一

5、BLOCKED：這幾個(gè)都表示排隊等著(zhù)其他事情

當前線(xiàn)程在等待鎖，導致了阻塞(阻塞狀態(tài)之一) --synchronized

6、WAITING：這幾個(gè)都表示排隊等著(zhù)其他事情

當前線(xiàn)程在等待喚醒，導致了阻塞(阻塞狀態(tài)之一) --wait

為啥要這么細分？這是非常有好處的：
開(kāi)發(fā)過(guò)程中經(jīng)常會(huì )遇到一種情況，程序 "卡死” 了
一些關(guān)鍵的線(xiàn)程，阻塞了
在分析卡死原因的時(shí)候，第一步就可以先來(lái)看看當前程序里的各種關(guān)鍵線(xiàn)程所處的狀態(tài)

5、線(xiàn)程狀態(tài)轉換簡(jiǎn)圖