Java線程是Java并發編程的基礎，理解Java線程的生命周期對于編寫高效、穩定的并發程序至關重要。本文將從兩個角度來介紹Java線程的生命周期，并通過代碼示例進行驗證。

一、復習

在Java中，線程的創建主要通過兩種方式：繼承Thread類或實現Runnable接口、Callnablee接口。以下是一個簡單的示例：

1.1 創建線程的方式

1.1.1 創建建方式一：繼承Thread類

步驟：

1. 創建自定義類繼承于Thread類，并重寫Thread類的run()方法。該run()方法的方法體就代表了線程要完成的任務。因此把run()方法稱為執行體。
2. 創建自定義類（Thread子類）的實例，即創建了線程對象。
3. 調用線程對象的start()方法來啟動該線程。

/**
 * Java中創建線程方式一：繼承Thread類
 */
public class ThreadTest extends Thread{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }
}

打印結果：

0
1
2
3
4
5
6
7
8
9

1.1.2 創建方式二：實現Runnable接口

步驟：

1. 創建自定義類實現于Runnable接口，并重寫該接口的run()方法，該run()方法的方法體同樣是該線程的線程執行體。
2. 創建自定義類（Runnable實現類）的實例，并依此實例作為Thread的target來創建Thread對象，該Thread對象才是真正的線程對象。
3. 調用線程對象的start()方法來啟動該線程。

/**
 * Java中創建線程方式二：實現Runnable接口
 */
public class RunnableTest implements Runnable{

    @Override
    public void run() {
        for (int i = 100; i < 110; i++) {
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        RunnableTest runnableTest = new RunnableTest();
        Thread thread = new Thread(runnableTest);
        thread.start();
    }
}

打印結果：

100
101
102
103
104
105
106
107
108
109

1.1.3 創建方式三：通過Callable和Future創建線程

Callable和Future出現的背景

一般創建線程時，使用上面兩種方式居多。但是這兩種方式都有一個缺陷：在執行完任務之后無法獲取執行結果。

如果需要獲取執行結果，就必須通過共享變量或者使用線程通信的方式來達到效果，這樣使用起來就比較麻煩。

而自從Java 1.5開始，就提供了Callable和Future，通過它們可以在任務執行完畢之后得到任務執行結果。

Callable和Future簡介

Callable接口可以理解成一段可以調用并返回結果的代碼（call方法）;

Future接口表示異步任務，是還沒有完成的任務給出的未來結果。

所以說Callable用于產生結果，Future用于獲取結果。這點可以在源碼里面分析得知。

源碼分析

先看Runnable源碼

Runnable位于java.lang包下，它是一個接口，在它里面聲明了一個方法叫做 run()：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

由于run()方法返回值為void類型，所以在執行完任務之后無法返回任何結果。

再看Callable源碼Callable位于java.util.concurrent包下，它也是一個接口，在它里面也只聲明了一個方法，只不過這個方法叫做call()：

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

可以看到，這是一個泛型接口，call()函數返回的類型就是傳遞進來的V類型。

Future源碼

Future就是對于具體的Runnable或者Callable任務的執行結果進行取消、查詢是否完成、獲取結果。必要時可以通過get方法獲取執行結果，該方法會阻塞直到任務返回結果。為什么這么說呢？看了它的源碼就知道了。

Future類位于java.util.concurrent包下，它也是一個接口

package java.util.concurrent;

public interface Future<V> {

	/**
     * 取消任務
     */
    boolean cancel(boolean mayInterruptIfRunning);

	/**
     * 任務是否被取消成功
     */
    boolean isCancelled();

	/**
     * 任務是否已經完成
     */
    boolean isDone();
	
	/**
     * 獲取執行結果
     */
    V get() throws InterruptedException, ExecutionException;

	/**
     * 獲取執行結果，支持超時
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

所以說Future一共給我們提供了三種功能：

• 能夠取消任務。
• 判斷任務是否完成。
• 能夠獲取任務執行結果。

但是因為Future只是一個接口，所以是無法直接用來創建對象使用的，因此就有了下面的FutureTask。

FutureTask實現于RunnableFuture接口，這個接口的定義如下：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

可以看到這個接口實現了Runnable和Future接口，接口中的具體實現由FutureTask來實現。這個類的兩個構造方法如下 ：

public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

	public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

如上提供了兩個構造函數，一個以Callable為參數，另外一個以Runnable為參數。這些類之間的關聯允許你基于FutureTask的Runnable特性（因為它實現了Runnable接口），把任務寫成Callable，然后封裝進一個由執行者調度并在必要時可以取消的FutureTask。

FutureTask可以由執行者調度，它對外提供的方法基本上就是Future和Runnable接口的組合：get()、cancel、isDone()、isCancelled()和run()，而run()方法通常都是由執行者調用，我們基本上不需要直接調用它。

通過Callable和Future創建一個線程

步驟:

1. 創建自定義類實現于Callable接口，并實現call()方法，該call()方法將作為線程執行體，并且有返回值。
2. 創建自定義類（Callable實現類）的實例，使用FutureTask類來包裝Callable對象，該FutureTask對象封裝了該Callable對象的call()方法的返回值。
3. 使用FutureTask對象作為Thread對象的target創建并啟動新線程。
4. 調用FutureTask對象的get()方法來獲得子線程執行結束后的返回值

示例：

/**
 * Java中創建線程方式三：Callable和FutureTask結合使用
 */
public class CallableTest implements Callable{

    @Override
    public Object call() throws Exception {
        int i = 1000;
        for ( ; i < 1010; i++) {
            System.out.println(i);
        }
        return 1111;
    }

    public static void main(String[] args) {
        CallableTest callableTest = new CallableTest();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableTest);
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            System.out.println("Result："+futureTask.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

    }
}

打印結果：

1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
Result：1111

1.2 面試題：Runable接口和Calla

返回值：

• Runnable接口的run()方法沒有返回值，它表示一個沒有返回結果的任務。
• Callable接口的call()方法有返回值，可以返回計算結果。

異常處理：

• Runnable接口的run()方法不能拋出受檢查異常，只能通過捕獲異常并在方法內部處理。
• Callable接口的call()方法可以拋出受檢查異常，調用者需要捕獲并處理異常。

使用方式

• Runnable接口通常用于執行沒有返回結果的任務，可以通過Thread類的構造函數來創建線程并傳遞一個Runnable對象。
• Callable接口通常用于執行有返回結果的任務，需要配合ExecutorService接口或Future接口來提交和執行任務。

返回結果獲取

• Runnable接口沒有提供直接獲取任務執行結果的方法。
• Callable接口的call()方法返回一個Future對象，通過該對象可以獲取任務的執行結果。ble接口的區別

二、線程池的生命周期

Java線程的狀態可以被劃分為五種或六種，這主要取決于你從哪個角度來看。在操作系統的傳統線程模型中，線程通常被分為五種狀態。

2.1 從JVM源代碼看線程周期：

1. 初始 (NEW) ：新創建了一個線程對象，但還沒有調用start ()方法3。
2. 運行 (RUNNABLE) ：Java線程中將就緒（ready）和運行中（running）兩種狀態籠統的稱為“運行”。
3. 阻塞 (BLOCKED) ：表示線程阻塞于鎖3。
4. 等待 (WAITING) ：進入該狀態的線程需要等待其他線程做出一些特定動作（通知或中斷）。
5. 超時等待 (TIMED_WAITING) ：該狀態不同于WAITING，它可以在指定的時間后自行返回
6. 終止 (TERMINATED) ：表示該線程已經執行完畢

2.2 從操作系統的層面來看：

1. 新建狀態 (New): 線程對象被創建后，就進入了新建狀態。例如，Thread thread = new Thread ()2。
2. 就緒狀態 (Runnable): 也被稱為“可執行狀態”。線程對象被創建后，其它線程調用了該對象的start ()方法，從而來啟動該線程。例如，thread.start ()。處于就緒狀態的線程，隨時可能被CPU調度執行2。
3. 運行狀態 (Running): 線程獲取CPU權限進行執行。需要注意的是，線程只能從就緒狀態進入到運行狀態2。
4. 阻塞狀態 (Blocked): 阻塞狀態是線程因為某種原因放棄CPU使用權，暫時停止運行。直到線程進入就緒狀態，才有機會轉到運行狀態。阻塞的情況分三種：等待阻塞、同步阻塞和其他阻塞2。
5. 死亡狀態 (Dead): 線程執行完了或者因異常退出了run ()方法，該線程結束生命周期2。

總結

操作系統層面的五種線程狀態和JVM的六種線程狀態是兩個不同層次的概念，它們之間并不是一一對應的關系。

JVM并不關心操作系統線程的實際狀態，從JVM看來，等待CPU使用權（操作系統狀態為可運行態）與等待I/O（操作系統處于等待狀態）沒有區別，都是在等待某種資源，所以都歸入RUNNABLE狀態。因此，操作系統層面的線程狀態并不直接影響JVM的線程狀態。

這兩者的主要區別在于它們關注的焦點不同：操作系統更關注線程對CPU和I/O資源的使用，而JVM更關注線程在Java程序中的行為。

在「JDK1.2之后」，Java線程模型已經確定了基于操作系統原生線程模型實現。因此，目前或者今后的JDK版本中，操作系統支持怎么樣的線程模型，在很大程度上決定了Java虛擬機的線程如何映射，這一點在不同的平臺上沒有辦法達成一致，虛擬機規范中也未限定Java線程需要使用哪種線程模型來實現。線程模型只對線程的并發規模和操作成本產生影響，對于Java程序來說，這些差異是透明的。

對應Oracle Sun JDK或者說Oracle Sun JVM而言，它的Windows版本和Linux版本都是使用「一對一的線程模型」實現的。

一對一的線程模型也就是一條Java線程就映射到一條輕量級進程（「Light Weight Process」）中，而一條輕量級線程又映射到一條內核線程（「Kernel-Level Thread」）。我們平時所說的線程，往往就是指輕量級進程（或者通俗來說我們平時新建的java.lang.Thread就是輕量級進程實例的一個"句柄"，因為一個java.lang.Thread實例會對應JVM里面的一個JavaThread實例，而JVM里面的JavaThread就應該理解為輕量級進程）。推算這個線程映射關系，可以知道，我們在應用程序中創建或者操作的java.lang.Thread實例最終會映射到系統的內核線程，如果我們惡意或者實驗性無限創建java.lang.Thread實例，最終會影響系統的正常運行甚至導致系統崩潰（可以在Windows開發環境中做實驗，確保內存足夠的情況下使用死循環創建和運行java.lang.Thread實例）。