Java语言定义的线程状态分析

时间 2019-11-16

标签 java 语言定义线程状态分析栏目 Java 繁體版

原文原文链接

说到线程，必定要谈到线程状态，不一样的状态说明线程正处于不一样的工做机制下，不一样的工做机制下某些动做可能对线程产生不一样的影响。html

Java语言定义了6中状态，而同一时刻，线程有且仅有其中的一种状态。要获取Java线程的状态可使用 java.lang.Thread类中定义的 getState()方法，获取当前线程的状态就可使用Thread.currentThread().getState()来获取。该方法返回的类型是一个枚举类型，是Thread内部的一个枚举，全称为“java.lang.Thread.State”，这个枚举中定义的类型列表就是Java语言这个级别对应的线程状态列表，包含了NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED这些值。java

如下是本文的目录大纲：算法

1、Java的几种线程状态说明apache

2、Java线程状态转换图tomcat

3、“VisualVM线程监控线程状态”与“Java线程状态”对应关系网络

如有不正之处请多多谅解，欢迎批评指正、互相讨论。app

请尊重做者劳动成果，转载请标明原文连接：dom

http://www.cnblogs.com/trust-freedom/p/6606594.htmlsocket

1、Java的几种线程状态说明

一、NEW（新建）ui

java.lang.Thread.State枚举中的NEW状态描述：

/**
 * Thread state for a thread which has not yet started.
 */
NEW

建立后还没有启动的线程处于这个状态。

意思是这个线程没有被start()启动，或者说还根本不是一个真正意义上的线程，从本质上讲这只是建立了一个Java外壳，尚未真正的线程来运行。

不表明调用了start()，状态就当即改变，中间还有一些步骤，若是在这个启动的过程当中有另外一个线程来获取它的状态，实际上是不肯定的，要看那些中间步骤是否已经完成了。

二、RUNNABLE（可运行）

java.lang.Thread.State枚举中的RUNNABLE状态描述：

/**
 * 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

RUNNABLE状态包括了操做系统线程状态中的Running和Ready，也就是处于此状态的线程可能正在运行，也可能正在等待系统资源，如等待CPU为它分配时间片，如等待网络IO读取数据。

RUNNABLE状态也能够理解为存活着正在尝试征用CPU的线程（有可能这个瞬间并无占用CPU，可是它可能正在发送指令等待系统调度）。因为在真正的系统中，并非开启一个线程后，CPU就只为这一个线程服务，它必须使用许多调度算法来达到某种平衡，不过这个时候线程依然处于RUNNABLE状态。

三、BLOCKED（阻塞）

java.lang.Thread.State枚举中的BLOCKED状态描述：

/**
 * 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}.
 * 当一个线程要进入synchronized语句块/方法时，若是没有获取到锁，会变成BLOCKED
 * 或者在调用Object.wait()后，被notify()唤醒，再次进入synchronized语句块/方法时，若是没有获取到锁，会变成BLOCKED
 */
BLOCKED

BLOCKED称为阻塞状态，或者说线程已经被挂起，它“睡着”了，缘由一般是它在等待一个“锁”，当尝试进入一个synchronized语句块/方法时，锁已经被其它线程占有，就会被阻塞，直到另外一个线程走完临界区或发生了相应锁对象的wait()操做后，它才有机会去争夺进入临界区的权利

在Java代码中，须要考虑synchronized的粒度问题，不然一个线程长时间占用锁，其它争抢锁的线程会一直阻塞，直到拥有锁的线程释放锁

处于BLOCKED状态的线程，即便对其调用 thread.interrupt()也没法改变其阻塞状态，由于interrupt()方法只是设置线程的中断状态，即作一个标记，不能唤醒处于阻塞状态的线程

注意：ReentrantLock.lock()操做后进入的是WAITING状态，其内部调用的是LockSupport.park()方法

四、WAITING（无限期等待）

/**
 * 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

处于这种状态的线程不会被分配CPU执行时间，它们要等待显示的被其它线程唤醒。这种状态一般是指一个线程拥有对象锁后进入到相应的代码区域后，调用相应的“锁对象”的wait()方法操做后产生的一种结果。变相的实现还有LockSupport.park()、Thread.join()等，它们也是在等待另外一个事件的发生，也就是描述了等待的意思。

如下方法会让线程陷入无限期等待状态：

（1）没有设置timeout参数的Object.wait()

（2）没有设置timeout参数的Thread.join()

（3）LockSupport.park()

注意：

LockSupport.park(Object blocker) 会挂起当前线程，参数blocker是用于设置当前线程的“volatile Object parkBlocker 成员变量”

parkBlocker 是用于记录线程是被谁阻塞的，能够经过LockSupport.getBlocker()获取到阻塞的对象，用于监控和分析线程用的。

“阻塞”与“等待”的区别：

（1）“阻塞”状态是等待着获取到一个排他锁，进入“阻塞”状态都是被动的，离开“阻塞”状态是由于其它线程释放了锁，不阻塞了；

（2）“等待”状态是在等待一段时间或者唤醒动做的发生，进入“等待”状态是主动的

如主动调用Object.wait()，如没法获取到ReentraantLock，主动调用LockSupport.park()，如主线程主动调用 subThread.join()，让主线程等待子线程执行完毕再执行

离开“等待”状态是由于其它线程发生了唤醒动做或者到达了等待时间

五、TIMED_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

处于这种状态的线程也不会被分配CPU执行时间，不过无需等待被其它线程显示的唤醒，在必定时间以后它们会由系统自动的唤醒。

如下方法会让线程进入TIMED_WAITING限期等待状态：

（1）Thread.sleep()方法

（2）设置了timeout参数的Object.wait()方法

（3）设置了timeout参数的Thread.join()方法

（4）LockSupport.parkNanos()方法

（5）LockSupport.parkUntil()方法

六、TERMINATED（结束）

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

已终止线程的线程状态，线程已经结束执行。换句话说，run()方法走完了，线程就处于这种状态。其实这只是Java语言级别的一种状态，在操做系统内部可能已经注销了相应的线程，或者将它复用给其余须要使用线程的请求，而在Java语言级别只是经过Java代码看到的线程状态而已。

2、Java线程状态转换图

上图为我的了解的线程状态转换的各类状况，若有不到位的地方欢迎交流指教。

3、“VisualVM线程监控线程状态”与“Java线程状态”对应关系

经过VisualVM监控JVM时，能够经过“线程”标签页查看JVM的线程信息，VisualVM的线程状态以下：

经过dump thread stack，并与VisualVM监控信息中的线程名称对应，找到的VisualVM每种线程状态的线程堆栈以下：（请关注重点信息）

一、运行

"http-bio-8080-Acceptor-0" daemon prio=6 tid=0x000000000d7b4800 nid=0xa264 runnable [0x000000001197e000]
      java.lang.Thread.State: RUNNABLE
            at java.net.DualStackPlainSocketImpl.accept0(Native Method)
            at java.net.DualStackPlainSocketImpl.socketAccept(DualStackPlainSocketImpl.java:131)
            at java.net.AbstractPlainSocketImpl.accept(AbstractPlainSocketImpl.java:398)
            at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:199)
            - locked <0x00000000c2303850> (a java.net.SocksSocketImpl)
            at java.net.ServerSocket.implAccept(ServerSocket.java:530)
            at java.net.ServerSocket.accept(ServerSocket.java:498)
            at org.apache.tomcat.util.net.DefaultServerSocketFactory.acceptSocket(DefaultServerSocketFactory.java:60)
            at org.apache.tomcat.util.net.JIoEndpoint$Acceptor.run(JIoEndpoint.java:220)
            at java.lang.Thread.run(Thread.java:745)