java中线程的状态

状态 说明
NEW 初始状态。线程刚刚被创建，并且start()方法还未被调用
RUNNABLE 运行状态。表示线程正在java虚拟机中执行，但是可能正在等待操作系统的其他资源，比如CPU
BLOCKED 阻塞状态。表示线程正在等待监视器锁。表示线程正在等待获取监视器锁，以便进入同步方法或者同步代码快，也有可能是从wait（）方法被唤醒而等待再次进入同步方法或者同步代码块
WAITING 等待状态。表示当前线程需要等待其他线程执行一些特殊操作，比如当前线程调用了a.wait()方法，它正在等待其他线程调用a.notify或a.notifyAll方法;如果当前线程调用了threada.join(),那么它在等待threada执行完成
TIMED_WAITING 超时等待。与WAITING的不同在于，该状态有超时时间
TERMINATED 终止状态，表示当前线程已经执行完毕

详细介绍：参考Thread内部类:State

WAITING与TIMED_WAITING: 
调用以下三个方法会进入WAITING状态： 
* Object.wait() 不设置超时时间 
* Thread.join() 不设置超时时间 
* LockSupport.park() 不设置超时时间 
调用下面的方法会进入TIMED_WAITING状态： 
* Object.wait(time) 
* Thread.join(time) 
* Thread.sleep(time) 
* LockSupport.parkNanos(time) 
* LockSupport.parkUntil(time)

通过jstack查看线程状态

jstack 是一个可以用来打印java进程中的线程堆栈信息的工具。一般都位于jdk安装目录的bin目录下。 
一般，jstack都用来检测死锁，以及分析当前程序运行状态。

使用方式

jstack [options] pid 
pid:即进程id，可以通过jps命令查看 
options:可选选项。一般常用的是-l和-m，-l用于打印详细的堆栈信息，包括当前线程获得到的同步器(AbstractOwnableSynchronizer)。-m则会打印包含C++或C的堆栈信息。

例如： 
命令：jstack 10968 则会把进程号为10968的进程所包含的线程信息打印出来。 
其中的部分结果如下：

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007fab88009800 nid=0x2add waiting on condition [0x00007fab8ee92000]
  2.    java.lang.Thread.State: WAITING (parking)
  3.     at sun.misc.Unsafe.park(Native Method)
  4.     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)
  5.     at test.DeadLockTest.main(DeadLockTest.java:17)

命令：jstack -l 10968则会包含当前线程获取到的同步器。 
其中的部分结果如下：

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007fab88009800 nid=0x2add waiting on condition [0x00007fab8ee92000]
  2.    java.lang.Thread.State: WAITING (parking)
  3.     at sun.misc.Unsafe.park(Native Method)
  4.     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)
  5.     at test.DeadLockTest.main(DeadLockTest.java:17)
  7.    Locked ownable synchronizers:
  8.     - None

可以看到，带-l参数的，在线程信息后面有个’ Locked ownable synchronizers:’信息。

关于jstack的使用，下面两篇文章写的很不错，非常建议一看: 
1. java-thread-dumps 
2. java-thread-dumps-2

不同线程状态在jstack信息中形式

我们来看一下，当线程处于不同状态的时候，通过jstack看到的是什么样子的。

WAITING状态

通过上面的讲解我们知道，线程进入waiting状态可以通过三种方式：1.Object.wait,2.Thread.join,3.LockSupport.park ，那么我们分别来看下，当程序分别通过这三种方式进入WAITING状态的时候，对应的jstack信息是怎样的。

1.Object.wait方式 
代码：

  
  
  1. public class WaitingTest {
  3.     public static void main(String[] args) throws InterruptedException {
  4.         // Object.wait
  5.         synchronized (WaitingTest.class) {
  6.             WaitingTest.class.wait();
  7.         }
  8.     }
  10. }

jstack 结果(省略其他部分，下同):

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f384c009800 nid=0x2d9c in Object.wait() [0x00007f385268b000]
  2.    java.lang.Thread.State: WAITING (on object monitor)
  3.     at java.lang.Object.wait(Native Method)
  4.     - waiting on <0x00000000d6ddb9a0> (a java.lang.Class for test.WaitingTest)
  5.     at java.lang.Object.wait(Object.java:502)
  6.     at test.WaitingTest.main(WaitingTest.java:8)
  7.     - locked <0x00000000d6ddb9a0> (a java.lang.Class for test.WaitingTest)

2.Thread.join方式 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.         // Thread.join
  3.         Thread thread = new Thread() {
  5.             @Override
  6.             public void run() {
  7.                 System.out.println("run");
  8.                 try {
  9.                     Thread.sleep(1000 * 300);
  10.                 } catch (InterruptedException e) {
  11.                     e.printStackTrace();
  12.                 }
  13.             }
  15.         };
  16.         thread.start();
  18.         // 当前线程调用thread线程的join方法
  19.         thread.join();
  20.         // 只有thread的run方法执行完成之后，才会执行输出
  21.         System.out.println("Current thread running");
  22.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f88cc009800 nid=0x2f10 in Object.wait() [0x00007f88d5b73000]
  2.    java.lang.Thread.State: WAITING (on object monitor)
  3.     at java.lang.Object.wait(Native Method)
  4.     - waiting on <0x00000000d6ddddf8> (a test.WaitingTest$1)
  5.     at java.lang.Thread.join(Thread.java:1245)
  6.     - locked <0x00000000d6ddddf8> (a test.WaitingTest$1)
  7.     at java.lang.Thread.join(Thread.java:1319)
  8.     at test.WaitingTest.main(WaitingTest.java:23)
  10.    Locked ownable synchronizers:
  11.     - None

3.LockSupport.park方式 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.         LockSupport.park();
  3.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f6efc009800 nid=0x2f88 waiting on condition [0x00007f6f034dd000]
  2.    java.lang.Thread.State: WAITING (parking)
  3.     at sun.misc.Unsafe.park(Native Method)
  4.     at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)
  5.     at test.WaitingTest.main(WaitingTest.java:8)
  7.    Locked ownable synchronizers:
  8.     - None
TIMED_WAITING

1.Object.wait(time) 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.         synchronized (WaitingTest.class) {
  3.             WaitingTest.class.wait(1000 * 50);
  4.         }
  5.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007fd598009800 nid=0x301b in Object.wait() [0x00007fd59eea0000]
  2.    java.lang.Thread.State: TIMED_WAITING (on object monitor)
  3.     at java.lang.Object.wait(Native Method)
  4.     - waiting on <0x00000000d6ddb9b8> (a java.lang.Class for test.WaitingTest)
  5.     at test.WaitingTest.main(WaitingTest.java:9)
  6.     - locked <0x00000000d6ddb9b8> (a java.lang.Class for test.WaitingTest)
  8.    Locked ownable synchronizers:
  9.     - None

2.Thread.join(time) 
代码:

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.         // Thread.join
  3.         Thread thread = new Thread() {
  5.             @Override
  6.             public void run() {
  7.                 System.out.println("run");
  8.                 try {
  9.                     Thread.sleep(1000 * 300);
  10.                 } catch (InterruptedException e) {
  11.                     e.printStackTrace();
  12.                 }
  13.             }
  15.         };
  16.         thread.start();
  18.         // 当前线程调用thread线程的join方法
  19.         thread.join(1000 * 200);
  20.         // 只有thread的run方法执行完成之后，才会执行输出
  21.         System.out.println("Current thread running");
  22.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f024c009800 nid=0x365c in Object.wait() [0x00007f0254768000]
  2.    java.lang.Thread.State: TIMED_WAITING (on object monitor)
  3.     at java.lang.Object.wait(Native Method)
  4.     - waiting on <0x00000000d6dddf40> (a test.WaitingTest$1)
  5.     at java.lang.Thread.join(Thread.java:1253)
  6.     - locked <0x00000000d6dddf40> (a test.WaitingTest$1)
  7.     at test.WaitingTest.main(WaitingTest.java:25)
  9.    Locked ownable synchronizers:
  10.     - None

3.Thread.sleep 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.     Thread.currentThread().sleep(1000 * 500);
  3. }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f54a8009800 nid=0x36eb waiting on condition [0x00007f54ae463000]
  2.    java.lang.Thread.State: TIMED_WAITING (sleeping)
  3.     at java.lang.Thread.sleep(Native Method)
  4.     at test.WaitingTest.main(WaitingTest.java:8)
  6.    Locked ownable synchronizers:
  7.     - None

4.LockSupport.parkNanos(time) 和 LockSupport.parkUntil(time) 两个方法类似 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException {
  2.     LockSupport.parkNanos(Long.MAX_VALUE);
  3. }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007eff98009800 nid=0x37b6 waiting on condition [0x00007effa0141000]
  2.    java.lang.Thread.State: TIMED_WAITING (parking)
  3.     at sun.misc.Unsafe.park(Native Method)
  4.     at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:338)
  5.     at test.WaitingTest.main(WaitingTest.java:8)
  7.    Locked ownable synchronizers:
  8.     - None
BLOCKED状态

BLOCKED状态，表示线程正在等待监视器锁。我们可以通过一个死锁的例子来分析。 
例子很简单，程序中有两个Waiter线程，WaiterA和WaitB，它们都需要获取两个锁：lock_1和lock_2,但是它们获取锁的顺序不同，因此导致了死锁。 
代码：

  
  
  1. public class WaitingTest {
  3.     private static Object lock_1 = new Object();
  4.     private static Object lock_2 = new Object();
  6.     public static void main(String[] args) throws InterruptedException {
  8.         new WaiterA().start();
  9.         new WaiterB().start();
  11.     }
  13.     static class WaiterA extends Thread {
  15.         @Override
  16.         public void run() {
  17.             // 先获取lock_1,然后再获取lock_2
  18.             synchronized (lock_1) {
  19.                 System.out.println("lock1 get,wait to get lock2");
  20.                 try {
  21.                     Thread.sleep(3 * 1000);
  22.                 } catch (InterruptedException e1) {
  23.                 }
  24.                 synchronized (lock_2) {
  25.                     System.out.println("lock2 get");
  26.                     try {
  27.                         Thread.sleep(1000 * 50);
  28.                     } catch (InterruptedException e) {
  29.                         e.printStackTrace();
  30.                     }
  31.                 }
  32.             }
  33.         }
  35.     }
  37.     static class WaiterB extends Thread {
  39.         @Override
  40.         public void run() {
  41.             // 先获取lock_2,然后再获取lock_1
  42.             synchronized (lock_2) {
  43.                 System.out.println("lock2 get,wait to get lock1");
  44.                 synchronized (lock_1) {
  45.                     System.out.println("lock1 get");
  46.                     try {
  47.                         Thread.sleep(1000 * 50);
  48.                     } catch (InterruptedException e) {
  49.                         e.printStackTrace();
  50.                     }
  51.                 }
  52.             }
  53.         }
  55.     }
  57. }

jstack:

  
  
  1. "Thread-1" #10 prio=5 os_prio=0 tid=0x00007f0d800dc800 nid=0x39da waiting for monitor entry [0x00007f0d47bfa000]
  2.    java.lang.Thread.State: BLOCKED (on object monitor)
  3.     at test.WaitingTest$WaiterB.run(WaitingTest.java:47)
  4.     - waiting to lock <0x00000000d6ddc510> (a java.lang.Object)
  5.     - locked <0x00000000d6ddc520> (a java.lang.Object)
  7.    Locked ownable synchronizers:
  8.     - None
  10. "Thread-0" #9 prio=5 os_prio=0 tid=0x00007f0d800da800 nid=0x39d9 waiting for monitor entry [0x00007f0d47cfb000]
  11.    java.lang.Thread.State: BLOCKED (on object monitor)
  12.     at test.WaitingTest$WaiterA.run(WaitingTest.java:27)
  13.     - waiting to lock <0x00000000d6ddc520> (a java.lang.Object)
  14.     - locked <0x00000000d6ddc510> (a java.lang.Object)
  16.    Locked ownable synchronizers:
  17.     - None

可以看到，上面Thread-1 和Thread-0的状态都是Blocked，原因是它们都在等待监视器锁，而Thread-1 已经获取到了锁0x00000000d6ddc520，正在等待获取0x00000000d6ddc510锁，而0x00000000d6ddc510锁已经被Thread-0获取到了，Thread-0反过来又正在等待获取0x00000000d6ddc520，而这个锁又被Thread-1获取了。 
在jstack的最后，还有如下信息：

  
  
  1. Found one Java-level deadlock:
  2. =============================
  3. "Thread-1":
  4.   waiting to lock monitor 0x00007f0d50004ed8 (object 0x00000000d6ddc510, a java.lang.Object),
  5.   which is held by "Thread-0"
  6. "Thread-0":
  7.   waiting to lock monitor 0x00007f0d500062c8 (object 0x00000000d6ddc520, a java.lang.Object),
  8.   which is held by "Thread-1"
  10. Java stack information for the threads listed above:
  11. ===================================================
  12. "Thread-1":
  13.     at test.WaitingTest$WaiterB.run(WaitingTest.java:47)
  14.     - waiting to lock <0x00000000d6ddc510> (a java.lang.Object)
  15.     - locked <0x00000000d6ddc520> (a java.lang.Object)
  16. "Thread-0":
  17.     at test.WaitingTest$WaiterA.run(WaitingTest.java:27)
  18.     - waiting to lock <0x00000000d6ddc520> (a java.lang.Object)
  19.     - locked <0x00000000d6ddc510> (a java.lang.Object)
  21. Found 1 deadlock.

就是说，已经发现了一个死锁，还有就是关于死锁的详细说明。

RUNNABLE状态

我们写一个BIO的server端，server端绑定一个端口，并通过accept()方法等待客户端链接。 
代码：

  
  
  1. public static void main(String[] args) throws InterruptedException, IOException {
  2.         ServerSocket serverSocket = new ServerSocket(9999);
  4.         while (true) {
  5.             Socket socket = serverSocket.accept();
  6.             // do something else
  7.             // ....
  8.         }
  10.     }

jstack:

  
  
  1. "main" #1 prio=5 os_prio=0 tid=0x00007f4b58009800 nid=0x3ab8 runnable [0x00007f4b5ff64000]
  2.    java.lang.Thread.State: RUNNABLE
  3.     at java.net.PlainSocketImpl.socketAccept(Native Method)
  4.     at java.net.AbstractPlainSocketImpl.accept(AbstractPlainSocketImpl.java:409)
  5.     at java.net.ServerSocket.implAccept(ServerSocket.java:545)
  6.     at java.net.ServerSocket.accept(ServerSocket.java:513)
  7.     at test.WaitingTest.main(WaitingTest.java:16)
  9.    Locked ownable synchronizers:
  10.     - None

可以看到，此时虽然程序在等待客户端接入，但是程序状态依然是RUNNABLE的。

TERMINATED和NEW状态

这两个状态分别表示线程生命终结和生命开始，在jstack中没有对应的信息显示。

总结：
  1. WAITING和TIMED_WAITING的主要不同就在于后者在等待的时候设置了超时时间
  2. 通过Object.wait，Thread.join两种方式进入的WAITING或者TIMED_WAITING,通过jstack查看显示的都是wait on monitor,而通过其他方式（Thread.sleep,LockSupport等）进入的WAITING或者TIMED_WAITING,通过jstack查看显示的都是waiting on condition。
  3. BLOCKED状态，通过jstack查看，显示的是waiting for monitor entry，注意与WAITING和TIMED_WAITING的区别。

java线程状态之间的转换

java线程通过不同的方法调用进入不同的状态，下面图描述的很清楚： 
java线程状态转换UML

参考资料

  1. https://sites.google.com/site/threaddumps/java-thread-dumps
  2. https://sites.google.com/site/threaddumps/java-thread-dumps-2
  3. 图片来源：http://www.uml-diagrams.org/examples/java-6-thread-state-machine-diagram-example.html

顺便推荐个很好的网站： 
Java中的UML图：http://www.uml-diagrams.org/examples/java-uml-examples.html

Pre: Kafka学习笔记之初见

Next: Java中的可重入(Reentrant)锁

Logo
华为开发者空间

华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。

更多推荐

cover

解析openGauss账本数据库

avatar 华为开发者空间
cover

GaussDB的向量化处理技术

avatar 华为开发者空间
cover

二十载岁月如磐，一位高校女教师的技术坚守之路

avatar 华为开发者空间