Java 多線程啓動爲什麼調用 start() 方法而不是 run() 方法？
多線程在工作中多多少少會用到，我們知道啓動多線程調用的是 start() 方法，而不是 run() 方法，你知道原因嗎？
在探討這個問題之前，我們先來了解一些多線程的基礎知識~
線程的狀態
Java 中，定義了 6 種線程狀態，在 Thread 類可以找到：
// 爲了節約空間，我刪除了註釋
public enum State {
NEW,//初始狀態
RUNNABLE,//運行狀態
BLOCKED,// 阻塞狀態
WAITING,//等待狀態
TIMED_WAITING,//超時等待狀態
TERMINATED;//終止狀態}
這 6 種狀態之間的關聯，可以看下面這張圖：
這張圖描述的還是非常詳細的，結合這張圖，來說說這幾種狀態分別代表着什麼意思：
1、NEW 表示線程創建成功，但沒有運行，在 new Thread 之後，沒有 start 之前，線程都處於 NEW 狀態；
2、RUNNABLE 表示線程正在運行中，當我們運行 strat 方法，子線程被創建成功之後，子線程的狀態變成 RUNNABLE；
3、TERMINATED 表示線程已經運行結束，子線程運行完成、被打斷、被中止，狀態都會從 RUNNABLE 變成 TERMINATED；
4、BLOCKED 表示線程被阻塞，如果線程正好在等待獲得 monitor lock 鎖，比如在等待進入 synchronized 修飾的代碼塊或方法時，會從 RUNNABLE 變成 BLOCKED；
5、 WAITING 和 TIMED_WAITING 都表示等待，現在在遇到 Object#wait、Thread#join、
LockSupport#park 這些方法時，線程就會等待另一個線程執行完特定的動作之後，才能結
束等待，只不過 TIMED_WAITING 是帶有等待時間的；
優先級
優先級代表線程執行的機會的大小，優先級高的可能先執行，低的可能後執行。
在 Java 源碼中，優先級從低到高分別是 1 到 10，線程默認 new 出來的優先級都是 5，源碼如下：
/**
- The minimum priority that a thread can have.
*/
public final static int MIN_PRIORITY = 1;
/**
- The default priority that is assigned to a thread.
*/
public final static int NORM_PRIORITY = 5;
/**
- The maximum priority that a thread can have.
*/
public final static int MAX_PRIORITY = 10;
線程得創建方式
我們創建多線程有兩種方式，一種是繼承 Thread 類，另一種是實現 Runnable 接口。兩種方式的使用，如下所示：
1、繼承 Thread，成爲 Thread 的子類
public class MyThread extends Thread{
@Override
public void run() {
System.out.println("我是通過繼承 Thread 類實現的~");
}
public static void main(String[] args) {
MyThread thread = new MyThread();
// 啓動線程
thread.start();
}}
2、實現 Runnable 接口
public class MyThread1 {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("我是通過 runnable 方式實現的~");
}
});
// 啓動線程
thread.start();
}}
不管使用哪一種方式，啓動線程都是thread.start()方法，如果你做過實驗的話，你會發現 thread.run()也可以執行，爲什麼就一定需要調用thread.start()方法呢？
先說說結論：首先通過對象.run()方法可以執行方法，但是不是使用的多線程的方式，就是一個普通的方法，要想實現多線程的方式，一定需要通過對象.start()方法。
想要弄明白一個問題，最好的辦法就是從源碼入手，我們也從這兩個方法的源碼開始，先來看看 start 方法的源碼：
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
// 沒有初始化，拋出異常
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
// 是否啓動的標識符
boolean started = false;
try {
// start0() 是啓動多線程的關鍵
// 這裏會創建一個新的線程，是一個 native 方法
// 執行完成之後，新的線程已經在運行了
start0();
// 主線程執行
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}}
start 方法的源碼也沒幾行代碼，註釋也比較詳細，最主要的是 start0() 方法，這個後面在解釋。再來看看 run() 方法的源碼：
@Override
public void run() {
// 簡單的運行，不會新起線程，target 是 Runnable
if (target != null) {
target.run();
}
}run() 方法的源碼就比較簡單的，就是一個普通方法的調用，這也印證了我們上面的結論。
接下來我們就來說一說這個 start0() 這個方法，這個是真正實現多線程的關鍵，start0() 代碼如下：
private native void start0();
start0 被標記成 native ，也就是本地方法，並不需要我們去實現或者瞭解，爲什麼 start0() 會標記成 native ？
這個要從 Java 跨平臺說起，看下面這張圖：
start() 方法調用 start0() 方法後，該線程並不一定會立馬執行，只是將線程變成了可運行狀態。具體什麼時候執行，取決於 CPU ，由 CPU 統一調度。
我們又知道 Java 是跨平臺的，可以在不同系統上運行，每個系統的 CPU 調度算法不一樣，所以就需要做不同的處理，這件事情就只能交給 JVM 來實現了，start0() 方法自然就表標記成了 native。
最後，總結一下，Java 中實現真正的多線程是 start 中的 start0() 方法，run() 方法只是一個普通的方法。