線程是一個動態執行的過程，線程也有“生老病死”的生命周期，線程的生命周期其實就是一個線程從創建到消亡的過程。對于有生命周期的事物，要學好它，思路非常簡單，只要能搞懂生命周期中各個節點的狀態轉換機制就可以了。

在Java語言中，線程的生命周期中要想確定一個線程的當前狀態，可調用getState方法。下面就借助getState方法來用實例分析線程的生命周期：

1.初始化

NEW表示線程創建了，但是還沒有開始執行。

public class NewThread implements Runnable{

    public static void main(String[] args) {

        Runnable runnable = new NewThread();

        Thread t = new Thread(runnable);

        log.info(t.getState().toString());

    }

    @Override

    public void run() {

    }

}

上面的代碼將會輸出：

NEW

2.可運行

Runnable表示線程正在運轉狀態。包括正在運行和準備運行兩種。

為什么這兩種都叫做Runnable呢？我們知道在多任務環境中，CPU的個數是有限的，所以任務都是輪循占有CPU來處理的，JVM中的線程調度器會為每個線程分配特定的執行時間，當執行時間結束后，線程調度器將會釋放CPU，以供其他的Runnable線程執行。

我們看一個Runnable的例子：

public class RunnableThread implements Runnable {

    @Override

    public void run() {

    }

    public static void main(String[] args) {

        Runnable runnable = new RunnableThread();

        Thread t = new Thread(runnable);

        t.start();

        log.info(t.getState().toString());

    }

}

上面的代碼將會輸出：

RUNNABLE

3.已封鎖

BLOCKED表示線程正在等待資源鎖，而當前該資源正在被其他線程占有。

我們舉個例子：

public class BlockThread implements Runnable {

    @Override

    public void run() {

        loopResource();

    }

    public static synchronized void loopResource() {

        while(true) {

            //無限循環

        }

    }

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new BlockThread());

        Thread t2 = new Thread(new BlockThread());

        t1.start();

        t2.start();

        Thread.sleep(1000);

        log.info(t1.getState().toString());

        log.info(t2.getState().toString());

        System.exit(0);

    }

}

上面的示例中，由于t1是無限循環，將會一直占有資源鎖，導致t2無法獲取資源鎖，從而處于BLOCKED狀態。

我們會得到如下結果：

12:40:11.710 [main] INFO com.flydean.BlockThread - RUNNABLE

12:40:11.713 [main] INFO com.flydean.BlockThread - BLOCKED

4.等候

WAITING狀態表示線程正在等待其他的線程執行特定的操作。有以下方法可以導致線程處于WAITTING狀態：

object.wait（）

thread.join（）

LockSupport.park（）

其中1，2方法不需要預期時間參數。

我們看下使用的例子：

public class WaitThread implements  Runnable{

    public static Thread t1;

    @Override

    public void run() {

        Thread t2 = new Thread(()->{

            try {

                Thread.sleep(10000);

            } catch (InterruptedException e) {

                Thread.currentThread().interrupt();

                log.error("Thread interrupted", e);

            }

            log.info("t1"+t1.getState().toString());

        });

        t2.start();

        try {

            t2.join();

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

            log.error("Thread interrupted", e);

        }

        log.info("t2"+t2.getState().toString());

    }

    public static void main(String[] args) {

        t1 = new Thread(new WaitThread());

        t1.start();

    }

}

在這個例子中，我們調用的t2.join（），這導致調用它的t1線程處于WAITTING狀態。

我們看下輸出結果：

12:44:12.958 [Thread-1] INFO com.flydean.WaitThread - t1 WAITING

12:44:12.964 [Thread-0] INFO com.flydean.WaitThread - t2 TERMINATED

TIMED_WAITING

TIMED_WAITING狀態表示在一個有限的時間等待其他線程執行特定的某些操作。

java中有5中方式來達到這種狀態：

thread.sleep（長毫秒）

wait（int timeout）或者wait（int timeout，int nanos）

thread.join（長毫秒）

LockSupport.parkNanos

LockSupport.parkUntil

我們舉個例子：

public class TimedWaitThread implements  Runnable{

    @Override

    public void run() {

        try {

            Thread.sleep(5000);

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

            log.error("Thread interrupted", e);

        }

    }

    public static void main(String[] args) throws InterruptedException {

        TimedWaitThread obj1 = new TimedWaitThread();

        Thread t1 = new Thread(obj1);

        t1.start();

        // The following sleep will give enough time for ThreadScheduler

        // to start processing of thread t1

        Thread.sleep(1000);

        log.info(t1.getState().toString());

    }

}

上面的例子中我們調用了Thread.sleep（5000）來讓線程處于TIMED_WAITING狀態。

看下輸出：

12:58:02.706 [main] INFO com.flydean.TimedWaitThread - TIMED_WAITING

那么問題來了，TIMED_WAITING和WAITTING有什么區別呢？

TIMED_WAITING如果在給定的時間沒有等到其他線程的特定操作，則被喚醒，從而進入爭奪資源鎖的狀態，如果能夠獲取到鎖，則變成Runnable狀態，如果獲取不到鎖，則變為變成BLOCKED狀態。

5.已終止

TERMINATED表示線程已經執行完畢。

public class TerminatedThread implements Runnable{

    @Override

    public void run() {

    }

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(new TerminatedThread());

        t1.start();

        // The following sleep method will give enough time for

        // thread t1 to complete

        Thread.sleep(1000);

        log.info(t1.getState().toString());

    }

}

輸出結果：

13:02:38.868 [main] INFO com.flydean.TerminatedThread - TERMINATED

理解Java線程的生命周期及各種狀態對于診斷多線程 Bug 非常有幫助，多線程程序很難調試，出了 Bug 基本上都是靠日志，靠線程 dump 來跟蹤問題，分析線程 dump 的一個基本功就是分析線程狀態，大部分的死鎖、饑餓、活鎖問題都需要跟蹤分析線程的狀態。關于這方面的詳細講解可以參考本站的Java多線程教程，里面對此舉出了大量的實例供我們學習論證。