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)
  6. Locked ownable synchronizers:
  7. - 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 {
  2. public static void main(String[] args) throws InterruptedException {
  3. // Object.wait
  4. synchronized (WaitingTest.class) {
  5. WaitingTest.class.wait();
  6. }
  7. }
  8. }

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() {
  4. @Override
  5. public void run() {
  6. System.out.println("run");
  7. try {
  8. Thread.sleep(1000 * 300);
  9. } catch (InterruptedException e) {
  10. e.printStackTrace();
  11. }
  12. }
  13. };
  14. thread.start();
  15. // 当前线程调用thread线程的join方法
  16. thread.join();
  17. // 只有thread的run方法执行完成之后，才会执行输出
  18. System.out.println("Current thread running");
  19. }

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)
  9. Locked ownable synchronizers:
  10. - 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)
  6. Locked ownable synchronizers:
  7. - 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)
  7. Locked ownable synchronizers:
  8. - None

2.Thread.join(time) 
代码:

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

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)
  8. Locked ownable synchronizers:
  9. - 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)
  5. Locked ownable synchronizers:
  6. - 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)
  6. Locked ownable synchronizers:
  7. - None

BLOCKED状态

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

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

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)
  6. Locked ownable synchronizers:
  7. - None
  8. "Thread-0" #9 prio=5 os_prio=0 tid=0x00007f0d800da800 nid=0x39d9 waiting for monitor entry [0x00007f0d47cfb000]
  9. java.lang.Thread.State: BLOCKED (on object monitor)
  10. at test.WaitingTest$WaiterA.run(WaitingTest.java:27)
  11. - waiting to lock <0x00000000d6ddc520> (a java.lang.Object)
  12. - locked <0x00000000d6ddc510> (a java.lang.Object)
  13. Locked ownable synchronizers:
  14. - 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"
  9. Java stack information for the threads listed above:
  10. ===================================================
  11. "Thread-1":
  12. at test.WaitingTest$WaiterB.run(WaitingTest.java:47)
  13. - waiting to lock <0x00000000d6ddc510> (a java.lang.Object)
  14. - locked <0x00000000d6ddc520> (a java.lang.Object)
  15. "Thread-0":
  16. at test.WaitingTest$WaiterA.run(WaitingTest.java:27)
  17. - waiting to lock <0x00000000d6ddc520> (a java.lang.Object)
  18. - locked <0x00000000d6ddc510> (a java.lang.Object)
  19. Found 1 deadlock.

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

RUNNABLE状态

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

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

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)
  8. Locked ownable synchronizers:
  9. - 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线程通过不同的方法调用进入不同的状态，下面图描述的很清楚： 

参考资料

  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)锁

java中线程的状态以及线程栈分析相关推荐

  1. Java中进入wait状态的线程被唤醒后会接着上次执行的地方往下执行还是会重新执行临界区的代码

    Java中进入wait状态的线程被唤醒后会接着上次执行的地方往下执行还是会重新执行临界区的代码 用一个例子来说明: 例子原理 启动一个线程A打印数字,从0打印到9,在数字等于5的时候,进入wait状态 ...

  2. JAVA中的多线程(八)：线程的优先级和yield方法

    JAVA中的多线程(八):线程的优先级和yield方法 优先级代表着抢资源的频率 所有线程默认优先级是5 yield()临时释放线程的执行权 1 class Demo implements Runna ...

  3. java解析xml实例_在java中使用dom解析xml的示例分析

    本篇文章介绍了,在java中使用dom解析xml的示例分析.需要的朋友参考下 dom是个功能强大的解析工具,适用于小文档 为什么这么说呢?因为它会把整篇xml文档装载进内存中,形成一颗文档对象树 总之 ...

  4. java 中如何正确的停止线程

    如何优雅的停止一个线程 1.为什么要停止线程 2.为何说要正确的停止线程 3.使用interrupt()停止线程 4.线程在通常三种情况下停止 4.1 普通情况 4.2 线程阻塞情况 4.3 传递中断 ...

  5. java thread 几个状态_Java-Thread 线程的几种状态

    Oracle JDK 定义中,线程一共有六种状态 NEW:未启动状态 Thread t= newThread() { @Overridepublic voidrun() { System.out.pr ...

  6. java中让步的_java 多线程—— 线程让步

    java 多线程 目录: 概述 第1 部分 yield()介绍 yield()的作用是让步.它能让当前线程由"运行状态"进入到"就绪状态",从而让其它具有相同优 ...

  7. Java基础学习系列--（七）彻底搞懂java中的【异常、线程】的使用

    第一章 异常 1.1 异常概念 异常,就是不正常的意思.在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是: 异常 :指的是程序在执行过程中, ...

  8. Java中创建线程需要使用的类_如何通过使用Java中的匿名类创建线程？

    甲线程是可以同时与该程序的其他部分被执行的功能.所有Java程序都有至少一个称为主线程的线程,该线程由Java虚拟机(JVM)在程序启动时由主线程调用main()方法创建. 在Java中,我们可以通过 ...

  9. JAVA中增强循环中用线程_在Java中以循环方式运行线程

    我是Java中的多线程和同步的新手.我正在尝试实现一项任务,其中给了我5个文件,每个文件将由一个特定线程读取.每个线程应从文件读取一行,然后将执行转发到下一个线程,依此类推.当所有5个线程都读取第一行 ...

最新文章

  1. H3C RIPv2配置任务
  2. VC调试信息输出 TRACE宏
  3. 【MCTalk Live】网易对话谷歌：如何成为一个顶50个的A+++++程序员
  4. android桌面小组件开发_快使用Scriptable自己开发一个iPhone小组件吧
  5. SpringTest2
  6. 原生js实现canvas气泡冒泡效果
  7. C++11系列学习之四----auto
  8. 简单的INSERT语句
  9. 数据增长率怎么算_2019 年“泰迪杯”数据分析职业技能大赛A题 超市销售数据分析...
  10. mysql下删改增语句_MySQL增删改查
  11. k8s 创建、切换、删除namespace
  12. 2021Eclipse下载与安装教程
  13. gsoap linux中文乱码,gsoap中文乱码及内存清理等问题的解决方案
  14. 编写第一个操作WORD文档的应用程序
  15. 给定字符串 s 和 t ，判断 s 是否为 t 的子序列
  16. 二胎准生证办理流程--很有用。
  17. Android平板能装fydeos,在 FydeOS 中如何安装安卓应用 - FydeOS 帮助手册
  18. position:absolute详解
  19. 4. 彤哥说netty系列之Java NIO实现群聊（自己跟自己聊上瘾了）
  20. 7-14 大小写转换 (10 分)(PTA题目)

热门文章

  1. 搭建Git本地服务器（转）
  2. C#中的复制在unity中使用
  3. POJ 2993 Emag eht htiw Em Pleh(模拟）
  4. 写在国产接口管理工具ApiPost 5.2.5发布后的一些话
  5. 性能测试之二——性能测试的流程
  6. java解决斐波那契数列（Fibonacci sequence）
  7. mysql syncmasterinfo_sync_master_info的一些说明
  8. 好看的php验证码,一个漂亮的PHP验证码_PHP教程
  9. 你还在犹豫要不要学习Java？不妨来看看我的见解如何？
  10. 说学习前端开发简单，如何才能成功上岸？