Java線程是Java并發(fā)編程的基礎(chǔ)，理解Java線程的生命周期對于編寫高效、穩(wěn)定的并發(fā)程序至關(guān)重要。本文將從兩個(gè)角度來介紹Java線程的生命周期，并通過代碼示例進(jìn)行驗(yàn)證。

一、復(fù)習(xí)

在Java中，線程的創(chuàng)建主要通過兩種方式：繼承Thread類或?qū)崿F(xiàn)Runnable接口、Callnablee接口。以下是一個(gè)簡單的示例：

1.1 創(chuàng)建線程的方式

1.1.1 創(chuàng)建建方式一：繼承Thread類

步驟：

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

/**
 * Java中創(chuàng)建線程方式一：繼承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();
    }
}

打印結(jié)果：

0
1
2
3
4
5
6
7
8
9

1.1.2 創(chuàng)建方式二：實(shí)現(xiàn)Runnable接口

步驟：

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

/**
 * Java中創(chuàng)建線程方式二：實(shí)現(xiàn)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();
    }
}

打印結(jié)果：

100
101
102
103
104
105
106
107
108
109

1.1.3 創(chuàng)建方式三：通過Callable和Future創(chuàng)建線程

Callable和Future出現(xiàn)的背景

一般創(chuàng)建線程時(shí)，使用上面兩種方式居多。但是這兩種方式都有一個(gè)缺陷：在執(zhí)行完任務(wù)之后無法獲取執(zhí)行結(jié)果。

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

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

Callable和Future簡介

Callable接口可以理解成一段可以調(diào)用并返回結(jié)果的代碼（call方法）;

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

所以說Callable用于產(chǎn)生結(jié)果，F(xiàn)uture用于獲取結(jié)果。這點(diǎn)可以在源碼里面分析得知。

源碼分析

先看Runnable源碼

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

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

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

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

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

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

Future源碼

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

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

package java.util.concurrent;

public interface Future<V> {

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

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

	/**
     * 任務(wù)是否已經(jīng)完成
     */
    boolean isDone();
	
	/**
     * 獲取執(zhí)行結(jié)果
     */
    V get() throws InterruptedException, ExecutionException;

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

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

• 能夠取消任務(wù)。
• 判斷任務(wù)是否完成。
• 能夠獲取任務(wù)執(zhí)行結(jié)果。

但是因?yàn)镕uture只是一個(gè)接口，所以是無法直接用來創(chuàng)建對象使用的，因此就有了下面的FutureTask。

FutureTask實(shí)現(xiàn)于RunnableFuture接口，這個(gè)接口的定義如下：

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

可以看到這個(gè)接口實(shí)現(xiàn)了Runnable和Future接口，接口中的具體實(shí)現(xiàn)由FutureTask來實(shí)現(xiàn)。這個(gè)類的兩個(gè)構(gòu)造方法如下 ：

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
    }

如上提供了兩個(gè)構(gòu)造函數(shù)，一個(gè)以Callable為參數(shù)，另外一個(gè)以Runnable為參數(shù)。這些類之間的關(guān)聯(lián)允許你基于FutureTask的Runnable特性（因?yàn)樗鼘?shí)現(xiàn)了Runnable接口），把任務(wù)寫成Callable，然后封裝進(jìn)一個(gè)由執(zhí)行者調(diào)度并在必要時(shí)可以取消的FutureTask。

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

通過Callable和Future創(chuàng)建一個(gè)線程

步驟:

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

示例：

/**
 * Java中創(chuàng)建線程方式三：Callable和FutureTask結(jié)合使用
 */
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();
        }

    }
}

打印結(jié)果：

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

1.2 面試題：Runable接口和Calla

返回值：

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

異常處理：

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

使用方式

• Runnable接口通常用于執(zhí)行沒有返回結(jié)果的任務(wù)，可以通過Thread類的構(gòu)造函數(shù)來創(chuàng)建線程并傳遞一個(gè)Runnable對象。
• Callable接口通常用于執(zhí)行有返回結(jié)果的任務(wù)，需要配合ExecutorService接口或Future接口來提交和執(zhí)行任務(wù)。

返回結(jié)果獲取

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

二、線程池的生命周期

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

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

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

2.2 從操作系統(tǒng)的層面來看：

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

總結(jié)

操作系統(tǒng)層面的五種線程狀態(tài)和JVM的六種線程狀態(tài)是兩個(gè)不同層次的概念，它們之間并不是一一對應(yīng)的關(guān)系。

JVM并不關(guān)心操作系統(tǒng)線程的實(shí)際狀態(tài)，從JVM看來，等待CPU使用權(quán)（操作系統(tǒng)狀態(tài)為可運(yùn)行態(tài)）與等待I/O（操作系統(tǒng)處于等待狀態(tài)）沒有區(qū)別，都是在等待某種資源，所以都?xì)w入RUNNABLE狀態(tài)。因此，操作系統(tǒng)層面的線程狀態(tài)并不直接影響JVM的線程狀態(tài)。

這兩者的主要區(qū)別在于它們關(guān)注的焦點(diǎn)不同：操作系統(tǒng)更關(guān)注線程對CPU和I/O資源的使用，而JVM更關(guān)注線程在Java程序中的行為。

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

對應(yīng)Oracle Sun JDK或者說Oracle Sun JVM而言，它的Windows版本和Linux版本都是使用「一對一的線程模型」實(shí)現(xiàn)的。

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