Java線程狀態分析

時間  2019-12-13
標籤 java 線程 狀態 分析 欄目 Java 简体版
原文   原文鏈接

Java線程的生命週期中，存在幾種狀態。在Thread類裏有一個枚舉類型State，定義了線程的幾種狀態，分別有：java

  1. NEW: 線程建立以後，可是尚未啓動(not yet started)。這時候它的狀態就是NEW
  2. RUNNABLE: 正在Java虛擬機下跑任務的線程的狀態。在RUNNABLE狀態下的線程可能會處於等待狀態， 由於它正在等待一些系統資源的釋放，好比IO
  3. BLOCKED: 阻塞狀態，等待鎖的釋放，好比線程A進入了一個synchronized方法，線程B也想進入這個方法，可是這個方法的鎖已經被線程A獲取了，這個時候線程B就處於BLOCKED狀態
  4. WAITING: 等待狀態，處於等待狀態的線程是因爲執行了3個方法中的任意方法。 1. Object的wait方法，而且沒有使用timeout參數; 2. Thread的join方法，沒有使用timeout參數 3. LockSupport的park方法。 處於waiting狀態的線程會等待另一個線程處理特殊的行爲。 再舉個例子，若是一個線程調用了一個對象的wait方法，那麼這個線程就會處於waiting狀態直到另一個線程調用這個對象的notify或者notifyAll方法後纔會解除這個狀態
  5. TIMED_WAITING: 有等待時間的等待狀態，好比調用瞭如下幾個方法中的任意方法，而且指定了等待時間，線程就會處於這個狀態。 1. Thread.sleep方法 2. Object的wait方法，帶有時間 3. Thread.join方法，帶有時間 4. LockSupport的parkNanos方法，帶有時間 5. LockSupport的parkUntil方法，帶有時間
  6. TERMINATED: 線程停止的狀態，這個線程已經完整地執行了它的任務

下面經過幾個例子再次說明一下在什麼狀況下，線程會處於這幾種狀態：app

NEW狀態

NEW狀態比較簡單，實例化一個線程以後，而且這個線程沒有開始執行，這個時候的狀態就是NEW：ide

Thread thread = new Thread();
System.out.println(thread.getState()); // NEW

RUNNABLE狀態

正在運行的狀態。工具

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        for(int i = 0; i < Integer.MAX_VALUE; i ++) {
            System.out.println(i);
        }
    }
}, "RUNNABLE-Thread");
thread.start();

使用jstack查看線程狀態：線程

"RUNNABLE-Thread" #10 prio=5 os_prio=31 tid=0x00007f8e04981000 nid=0x4f03 runnable [0x000070000124c000]
   java.lang.Thread.State: RUNNABLE
  at java.io.FileOutputStream.writeBytes(Native Method)
  at java.io.FileOutputStream.write(FileOutputStream.java:315)
  at java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)
  at java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)
  - locked <0x000000079764cc50> (a java.io.BufferedOutputStream)
  at java.io.PrintStream.write(PrintStream.java:482)
  - locked <0x0000000797604dc0> (a java.io.PrintStream)
  at sun.nio.cs.StreamEncoder.writeBytes(StreamEncoder.java:221)
  at sun.nio.cs.StreamEncoder.implFlushBuffer(StreamEncoder.java:291)
  at sun.nio.cs.StreamEncoder.flushBuffer(StreamEncoder.java:104)
  - locked <0x0000000797604d78> (a java.io.OutputStreamWriter)
  at java.io.OutputStreamWriter.flushBuffer(OutputStreamWriter.java:185)
  at java.io.PrintStream.write(PrintStream.java:527)
  - eliminated <0x0000000797604dc0> (a java.io.PrintStream)
  at java.io.PrintStream.print(PrintStream.java:597)
  at java.io.PrintStream.println(PrintStream.java:736)
  - locked <0x0000000797604dc0> (a java.io.PrintStream)
  at study.thread.ThreadStateTest$1.run(ThreadStateTest.java:23)
  at java.lang.Thread.run(Thread.java:745)

BLOCKED狀態

線程A和線程B都須要持有lock對象的鎖才能調用方法。若是線程A持有鎖，那麼線程B處於BLOCKED狀態；若是線程B持有鎖，那麼線程A處於BLOCKED狀態。例子中使用Thread.sleep方法主要是用於調試方便：調試

final Object lock = new Object();
Thread threadA = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            System.out.println(Thread.currentThread().getName() + " invoke");
            try {
                Thread.sleep(20000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}, "BLOCKED-Thread-A");
Thread threadB = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            System.out.println(Thread.currentThread().getName() + " invoke");
            try {
                Thread.sleep(20000l);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}, "BLOCKED-Thread-B");
threadA.start();
threadB.start();

使用jstack查看線程狀態。因爲線程A先執行，線程B後執行，並且線程A執行後調用了Thread.sleep方法，因此線程A會處於TIMED_WAITING狀態，線程B處於BLOCKED狀態：code

"BLOCKED-Thread-B" #11 prio=5 os_prio=31 tid=0x00007fa7db8ff000 nid=0x5103 waiting for monitor entry [0x000070000134f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
  at study.thread.ThreadStateTest$3.run(ThreadStateTest.java:50)
  - waiting to lock <0x0000000795a03bf8> (a java.lang.Object)
  at java.lang.Thread.run(Thread.java:745)

"BLOCKED-Thread-A" #10 prio=5 os_prio=31 tid=0x00007fa7db15a000 nid=0x4f03 waiting on condition [0x000070000124c000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
  at java.lang.Thread.sleep(Native Method)
  at study.thread.ThreadStateTest$2.run(ThreadStateTest.java:39)
  - locked <0x0000000795a03bf8> (a java.lang.Object)
  at java.lang.Thread.run(Thread.java:745)

WAITING狀態

Object的wait方法、Thread的join方法以及Conditon的await方法都會產生WAITING狀態。對象

1.沒有時間參數的Object的wait方法生命週期

final Object lock = new Object();
Thread threadA = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            try {
                lock.wait();
                System.out.println("wait over");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}, "WAITING-Thread-A");
Thread threadB = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            try {
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.notifyAll();
        }
    }
}, "WAITING-Thread-B");
threadA.start();
threadB.start();

WAITING-Thread-A調用了lock的wait，處於WAITING狀態：資源

"WAITING-Thread-B" #11 prio=5 os_prio=31 tid=0x00007f8de992d800 nid=0x5103 waiting on condition [0x000070000134f000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
  at java.lang.Thread.sleep(Native Method)
  at study.thread.ThreadStateTest$5.run(ThreadStateTest.java:84)
  - locked <0x0000000795a03e40> (a java.lang.Object)
  at java.lang.Thread.run(Thread.java:745)

"WAITING-Thread-A" #10 prio=5 os_prio=31 tid=0x00007f8dea193000 nid=0x4f03 in Object.wait() [0x000070000124c000]
   java.lang.Thread.State: WAITING (on object monitor)
  at java.lang.Object.wait(Native Method)
  - waiting on <0x0000000795a03e40> (a java.lang.Object)
  at java.lang.Object.wait(Object.java:502)
  at study.thread.ThreadStateTest$4.run(ThreadStateTest.java:71)
  - locked <0x0000000795a03e40> (a java.lang.Object)
  at java.lang.Thread.run(Thread.java:745)

2.Thread的join方法

Thread threadA = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread-A over");
    }
}, "WAITING-Thread-A");
threadA.start();
try {
    threadA.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}

主線程main處於WAITING狀態：

"WAITING-Thread-A" #10 prio=5 os_prio=31 tid=0x00007fd2d5100000 nid=0x4e03 waiting on condition [0x000070000124c000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
  at java.lang.Thread.sleep(Native Method)
  at study.thread.ThreadStateTest$6.run(ThreadStateTest.java:103)
  at java.lang.Thread.run(Thread.java:745)
"main" #1 prio=5 os_prio=31 tid=0x00007fd2d3815000 nid=0x1003 in Object.wait() [0x0000700000182000]
   java.lang.Thread.State: WAITING (on object monitor)
  at java.lang.Object.wait(Native Method)
  - waiting on <0x0000000795a03ec0> (a java.lang.Thread)
  at java.lang.Thread.join(Thread.java:1245)
  - locked <0x0000000795a03ec0> (a java.lang.Thread)
  at java.lang.Thread.join(Thread.java:1319)
  at study.thread.ThreadStateTest.WAITING_join(ThreadStateTest.java:118)
  at study.thread.ThreadStateTest.main(ThreadStateTest.java:13)
  at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
  at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
  at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
  at java.lang.reflect.Method.invoke(Method.java:483)
  at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)

3.沒有時間參數的Condition的await方法

Condition的await方法跟Obejct的wait方法原理是同樣的，故也是WAITING狀態

TIMED_WAITING狀態

TIMED_WAITING狀態跟TIMEING狀態相似，是一個有等待時間的等待狀態，不會一直等待下去。

最簡單的TIMED_WAITING狀態例子就是Thread的sleep方法：

Thread threadA = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread-A over");
    }
}, "WAITING-Thread-A");
threadA.start();
try {
    Thread.sleep(5000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.println(threadA.getState()); // TIMED_WAITING

或者是Object的wait方法帶有時間參數、Thread的join方法帶有時間參數也會讓線程的狀態處於TIMED_WAITING狀態。

TERMINATED

線程終止的狀態，線程執行完成，結束生命週期。

Thread threadA = new Thread();
threadA.start();
try {
    Thread.sleep(5000l);
} catch (InterruptedException e) {
    e.printStackTrace();
}
System.out.println(threadA.getState()); // TERMINATED

總結

瞭解線程的狀態能夠分析一些問題。

好比線程處於BLOCKED狀態，這個時候能夠分析一下是否是lock加鎖的時候忘記釋放了，或者釋放的時機不對。致使另外的線程一直處於BLOCKED狀態。

好比線程處於WAITING狀態，這個時候能夠分析一下notifyAll或者signalAll方法的調用時機是否不對。

java自帶的jstack工具能夠分析查看線程的狀態、優先級、描述等具體信息。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程