java中線程的生命周期

文章目錄

• java中Thread的狀態
• NEW
• Runnable
• BLOCKED
• WAITING
• TIMED_WAITING
• TERMINATED

java中線程的生命周期

線程是java中繞不過去的一個話題， 今天本文將會詳細講解java中線程的生命周期，希望可以給大家一些啟發。

java中Thread的狀態

java中Thread有6種狀態，分別是：

1. NEW - 新創建的Thread，還沒有開始執行
2. RUNNABLE - 可運行狀態的Thread，包括准備運行和正在運行的。
3. BLOCKED - 正在等待資源鎖的線程
4. WAITING - 正在無限期等待其他線程來執行某個特定操作
5. TIMED_WAITING - 在一定的時間內等待其他線程來執行某個特定操作
6. TERMINATED - 線程執行完畢

我們可以用一個圖來直觀的表示：

JDK代碼中的定義如下：

public enum State {
        /** * Thread state for a thread which has not yet started. */
        NEW,

        /** * Thread state for a runnable thread. A thread in the runnable * state is executing in the Java virtual machine but it may * be waiting for other resources from the operating system * such as processor. */
        RUNNABLE,

        /** * Thread state for a thread blocked waiting for a monitor lock. * A thread in the blocked state is waiting for a monitor lock * to enter a synchronized block/method or * reenter a synchronized block/method after calling * {@link Object#wait() Object.wait}. */
        BLOCKED,

        /** * Thread state for a waiting thread. * A thread is in the waiting state due to calling one of the * following methods: * <ul> * <li>{@link Object#wait() Object.wait} with no timeout</li> * <li>{@link #join() Thread.join} with no timeout</li> * <li>{@link LockSupport#park() LockSupport.park}</li> * </ul> * * <p>A thread in the waiting state is waiting for another thread to * perform a particular action. * * For example, a thread that has called <tt>Object.wait()</tt> * on an object is waiting for another thread to call * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on * that object. A thread that has called <tt>Thread.join()</tt> * is waiting for a specified thread to terminate. */
        WAITING,

        /** * Thread state for a waiting thread with a specified waiting time. * A thread is in the timed waiting state due to calling one of * the following methods with a specified positive waiting time: * <ul> * <li>{@link #sleep Thread.sleep}</li> * <li>{@link Object#wait(long) Object.wait} with timeout</li> * <li>{@link #join(long) Thread.join} with timeout</li> * <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li> * <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li> * </ul> */
        TIMED_WAITING,

        /** * Thread state for a terminated thread. * The thread has completed execution. */
        TERMINATED;
    }

NEW

NEW 表示線程創建了，但是還沒有開始執行。我們看一個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

Runnable

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

BLOCKED

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

WAITING

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

1. object.wait()
2. thread.join()
3. 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中方式來達到這種狀態：

1. thread.sleep(long millis)
2. wait(int timeout) 或者 wait(int timeout, int nanos)
3. thread.join(long millis)
4. LockSupport.parkNanos
5. 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狀態。

TERMINATED

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

本文的例子可以參考https://github.com/ddean2009/learn-java-concurrency/tree/master/thread-lifecycle

更多教程請參考 flydean的博客