Java中的线程状态
说到线程，一定要谈到线程状态，不同的状态说明线程正处于不同的工作机制下，不同的工作机制下某些动作可能对线程产生不同的影响。
Java语言定义了6中状态，而同一时刻，线程有且仅有其中的一种状态。要获取Java线程的状态可以使用 java.lang.Thread类中定义的 getState()方法，获取当前线程的状态就可以使用Thread.currentThread().getState()来获取。该方法返回的类型是一个枚举类型，是Thread内部的一个枚举，全称为“java.lang.Thread.State”，这个枚举中定义的类型列表就是Java语言这个级别对应的线程状态列表，包含了NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED这六种状态。
一、Java中几种状态的说明
根据Java源码中Thread类的状态描述：
1.NEW
java.lang.Thread.State枚举中的NEW状态描述：
/**
* Thread state for a thread which has not yet started.
*/
NEW
线程创建之后，但是还没有启动(not yet started)。这时候它的状态就是NEW。
2.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，这两个状态在Java中是没有的，便于理解加上的。也就是处于此状态的线程可能正在运行（Running），也可能正在准备状态（Ready）等待系统资源，如等待CPU为它分配时间片，如等待网络IO读取数据。
3.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}.
*/
BLOCKED
BLOCKED称为阻塞状态，原因通常是它在等待一个“锁”，当尝试进入一个synchronized语句块/方法时，锁已经被其它线程占有，就会被阻塞，直到另一个线程走完临界区或发生了相应锁对象的wait()操作后，它才有机会去争夺进入临界区的权利
在Java代码中，需要考虑synchronized的粒度问题，否则一个线程长时间占用锁，其它争抢锁的线程会一直阻塞，直到拥有锁的线程释放锁
处于BLOCKED状态的线程，即使对其调用 thread.interrupt()也无法改变其阻塞状态，因为interrupt()方法只是设置线程的中断状态，即做一个标记，不能唤醒处于阻塞状态的线程
注意：ReentrantLock.lock()操作后进入的是WAITING状态，其内部调用的是LockSupport.park()方法
4.WAITING
java.lang.Thread.State枚举中的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执行时间，它们要等待被其它线程唤醒。
以下几种方法会导致线程进入等待状态：
1.Object.wait()
2.Thread.join()
3.LockSupport.park()
直到其他线程执行以下几种方法才会退出这种状态：
1.Object.notify()
2.Object.notifyAll()
5.TIMED_WAITING
java.lang.Thread.State枚举中的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
6.TERMINATED
java.lang.Thread.State枚举中的TERMINATED状态描述：
/**
* Thread state for a terminated thread.
* The thread has completed execution.
*/
TERMINATED
已终止线程的线程状态，线程已经结束执行。换句话说，run()方法走完了，线程就处于这种状态。其实这只是Java语言级别的一种状态，在操作系统内部可能已经注销了相应的线程，或者将它复用给其他需要使用线程的请求，而在Java语言级别只是通过Java代码看到的线程状态而已。
二、Java线程状态转换图
三、举例说明
NEW状态：
NEW状态比较简单，实例化一个线程之后，并且这个线程没有开始执行，这个时候的状态就是NEW：
Thread thread = new Thread();
System.out.println(thread.getState()); // NEWRUNNABLE状态：
正在运行的状态。
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状态：
"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状态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工具可以分析查看线程的状态、优先级、描述等具体信息。
参考
http://www.cnblogs.com/trust-freedom/p/6606594.html
https://fangjian0423.github.io/2016/06/04/java-thread-state/