java中，线程的状态使用一个枚举类型来描述的。这个枚举一共有6个值: NEW(新建)、RUNNABLE(运行)、BLOCKED(锁池)、TIMED_WAITING(定时等待)、WAITING(等待)、TERMINATED(终止、结束)。
但是我发现大多数人的理解和上面的这六种还是有些差别，通常会加上阻塞状态，可运行状态，挂起状态。
这是Thread类描述线程状态的枚举类的源代码：
public enum State { /** * Thread state for a thread which has not yet started. */ NEW, /** * 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, /** * 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, /** * Thread state for a waiting thread. * A thread is in the waiting state due to calling one of the * following methods: **
@link Object#wait() Object.wait} with no timeout *- {
{ @link #join() Thread.join} with no timeout *{ @link LockSupport#park() LockSupport.park} * * *A thread in the waiting state is waiting for another thread to * perform a particular action. * * For example, a thread that has called Object.wait() * on an object is waiting for another thread to call * Object.notify() or Object.notifyAll() on * that object. A thread that has called Thread.join() * is waiting for a specified thread to terminate.
*/ 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: **
@link #sleep Thread.sleep} *- {
{ @link Object#wait(long) Object.wait} with timeout *{ @link #join(long) Thread.join} with timeout *{ @link LockSupport#parkNanos LockSupport.parkNanos} *{ @link LockSupport#parkUntil LockSupport.parkUntil} * */ TIMED_WAITING, /** * Thread state for a terminated thread. * The thread has completed execution. */ TERMINATED; }
一、大多数人对线程状态以及状态转换的理解
线程的状态转换：
当一个线程创建以后，就处于新建状态。那什么时候这个状态会改变呢？只要它调用的start()方法，线程就进入了锁池状态。
进入锁池以后就会参与锁的竞争，当它获得锁以后还不能马上运行，因为一个单核CPU在某一时刻，只能执行一个线程，所以他需要操作系统分配给它时间片，才能执行。所以人们通常把一个线程在获得锁后，获得系统时间片之前的状态称之为可运行状态，但Java源代码里面并没有可运行状态这一说。
当一个持有对象锁的线程获得CPU时间片以后，开始执行这个线程，此时叫做运行状态。
当一个线程正常执行完，那么就进入终止（死亡）状态。系统就会回收这个线程占用的资源。
但是，线程的执行并不是那么顺利的。一个正在运行的线程有可能会进入I/O交互，还可能调用sleep()方法，还有可能在当前线程当中有其它线程调用了join()方法。这时候线程就进入了阻塞状态（但这也只是人们在理解的时候意淫加上去的，源代码里也没有定义这一个状态）。阻塞状态的线程是没有释放对象锁的。当I/O交互完成，或sleep()方法完成，或其它调用join()方法的线程执行完毕。阻塞状态的线程就会恢复到可运行状态，此时如果再次获得CPU时间片就会进入运行状态。
一个处于运行状态的线程还可能调用wait()方法、或者带时间参数的wait(long milli)方法。这时候线程就会将对象锁释放，进入等待队列里面（如果是调用wait()方法则进入等待状态，如果是调用带时间参数的则进入定时等待状态）。
一个线程如果的调用了带时间参数的wait(long milli)方法进入了定时等待状态，那么只要时间一到就会进入锁池状态，并不需要notify()或notifyAll()方法来唤醒它。如果调用的是不带时间参数的wait()则需要notify()或notifyAll()这两个方法来唤醒它然后进入锁池状态。进入锁池状态以后继续参与锁的竞争。
当一个处于运行状态的线程调用了suspend()方法以后，它就会进入挂起状态（这一方法已经过时不建议使用）。挂起状态的线程也没有释放对象锁，它需要调用resume()方法以后才能恢复到可运行状态。将线程挂起容易导致程序死锁。
下面是我自己画线程状态转换图：
这是大多数对一个线程的状态的理解。我以前也是这么理解的，但是，现在我对线程的状态有了新的理解。这与大多数人的理解有些不一样。
二、我对线程状态以及转换的理解
下面是我对线程的自己的理解，如果有不对的地方希望懂的人可以指出来一起讨论一下。
据官方源码，一个线程有六个状态，没有阻塞状态，没有可运行，没有挂起状态。
所以，现在我要提出一个观点：一个处于等待状态、定时等待状态的线程它也可能持有对象锁。例如调用sleep(long millis)会使线程进入等待状态，但是没有释放锁。
线程没有阻塞状态，那一个正在运行的线程进入I/O，或调用sleep()方法，或当前线程当中有其它线程调用了join()方法时，线程就会进入什么状态呢，它总得有六个当中的一个吧。
①、当线程调用sleep()方法或当前线程中有其他线程调用了带时间参数的join()方法的时候进入了定时等待状态（TIMED_WAITING）。
②、当其他线程调用了不带时间参数的join()方法时进入等待状态(WAITING)。
③、当线程遇到I/O的时候还是运行状态（RUNNABLE）。
④、当一个线程调用了suspend()方法挂起的时候它还是运行状态（RUNNABLE）。
现在我要来证明一下以上四点，如果证明过程有误，希望能够得到指正。这些代码的可以直接复制来运行一下。
证明一：当线程调用sleep()方法的时候进入了定时等待状态。
现在两个线程t1、t2，t1持有t2的一个引用。启动两个线程，t2启动后立即睡眠，让t1打印t2的状态。这样就可以看到睡眠时候的线程是六个当中的哪一个状态了。
public class Test1 { public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread2 t2 = new Thread2(); t1.setThread2(t2); t1.start(); t2.start(); } } //Thread1负责打印两个线程的状态。 class Thread1 extends Thread { private Thread2 t2; public void setThread2(Thread2 t2) { this.t2 = t2; } @Override public void run() { System.out.println("进入t1线程"); for(int i = 0; i < 5; i++) { try { System.out.println("t1 的状态： " + getState()); System.out.println("t2 的状态： " + t2.getState()); System.out.println(); //为了减少打印次数，所以t1每打印一次睡1秒 Thread.sleep(1000); } catch (InterruptedException e) { } } } } class Thread2 extends Thread { @Override public void run() { System.out.println("进入t2线程，马上进入睡眠"); try { //睡眠5秒钟。 sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("t2睡眠结束"); } }
上面的程序执行打印的结果
说明调用sleep()方法以后线程处于定时等待状态（TIMED_WAITING）。至于网上一直说的处于等待状态的线程不持有对象锁这种说法，我不知道这是官方给出的还是人们自己定义的。
证明二：当其他线程调用了join()方法时进入等待状态。
现在有三个线程t1 、t2 、t3。t1负责打印三个线程的状态。t2线程持有t3线程的引用，当进入t2线程以后，立即启动t3线程，并调用t3.join()方法。当t3加入后t2就是等待状态。
public class Test1 { public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread2 t2 = new Thread2(); Thread3 t3 = new Thread3(); //t1需要持有t2,t3的引用，以便打印他们的状态。 t1.setThread2(t2,t3); //t2需要持有t3的引用，以便t3能够在t2执行时加入(调用join()方法) t2.setTh3(t3); t1.start(); t2.start(); } } //Thread1负责打印所有线程的状态。 class Thread1 extends Thread { private Thread2 t2; private Thread3 t3; public void setThread2(Thread2 t2, Thread3 t3) { this.t2 = t2; this.t3 = t3; } @Override public void run() { System.out.println("进入t1线程"); for(int i = 0; i < 5; i++) { try { System.out.println("t1 的状态： " + getState()); System.out.println("t2 的状态： " + t2.getState()); System.out.println("t3 的状态： " + t3.getState()); System.out.println(); //为了减少打印次数，所以t1每打印一次睡1秒 Thread.sleep(1000); } catch (InterruptedException e) { } } } } class Thread2 extends Thread { private Thread3 t3; public void setTh3(Thread3 t3) { this.t3 = t3; } //当进入t2线程以后马上启动t3线程并调用join()方法。 @Override public void run() { System.out.println("进入t2线程，t3准备加入(调用join()方法)"); t3.start(); try { t3.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("t2执行结束"); } } class Thread3 extends Thread { @Override public void run() { System.out.println("进入t3线程，准备睡眠"); //本来是想让t3线程做加法运算的，奈何电脑算太快了，所以改为睡眠。因为睡眠不释放锁，所以效果一样。 try { sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("t3线程结束"); } }
这是运行的打印结果，当t3加入后t2处于等待状态
根据结果看，说明当一个正在执行的线程在其他线程调用join()方法以后进入了等待状态。
证明三：当一个线程调用了suspend()方法的时候它还是运行状态（RUNNABLE）。
package com.zcd.observe; public class Test1 { public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread2 t2 = new Thread2(); //t1需要持有t2,以便打印状态，和控制它恢复运行。 t1.setThread2(t2); t1.start(); t2.start(); } } //Thread1负责打印所有线程的状态。 class Thread1 extends Thread { private Thread2 t2; public void setThread2(Thread2 t2) { this.t2 = t2; } @Override public void run() { System.out.println("进入t1线程"); for(int i = 0; i < 6; i++) { try { System.out.println("t1 的状态： " + getState()); System.out.println("t2 的状态： " + t2.getState()); System.out.println(); if(i == 3) { //恢复t2的运行。 t2.resume(); } //为了减少打印次数，所以t1每打印一次睡1秒 Thread.sleep(1000); } catch (InterruptedException e) { } } } } class Thread2 extends Thread { @Override public void run() { System.out.println("进入t2线程，挂起"); //将线程挂起。让t1来控制它的恢复运行。 suspend(); System.out.println("t2已经恢复运行"); System.out.println("t2正在打印1"); System.out.println("t2正在打印2"); System.out.println("t2正在打印3"); System.out.println("t2线程结束"); } }
执行结果截图
说明：当一个线程调用了suspend()方法的时候它还是运行状态（RUNNABLE）。
证明四：当线程遇到I/O的时候还是运行状态。
package com.zcd.observe; import java.util.Scanner; public class Test1 { public static void main(String[] args) { Thread1 t1 = new Thread1(); Thread2 t2 = new Thread2(); t1.setThread2(t2); t1.start(); t2.start(); } } //Thread1负责打印所有线程的状态。 class Thread1 extends Thread { private Thread2 t2; public void setThread2(Thread2 t2) { this.t2 = t2; } @Override public void run() { System.out.println("进入t1线程"); for(int i = 0; i < 6; i++) { try { System.out.println("t1 的状态： " + getState()); System.out.println("t2 的状态： " + t2.getState()); System.out.println(); //为了减少打印次数，所以t1每打印一次睡1秒 Thread.sleep(1000); } catch (InterruptedException e) { } } System.out.println("进入t1线程结束"); } } class Thread2 extends Thread { @Override public void run() { System.out.println("进入t2线程"); //让线程进入I/O System.out.println("请输入数据："); Scanner scan = new Scanner(System.in); String read = scan.nextLine(); System.out.println("您输入的数据为："+read); System.out.println("t2线程结束"); } }
执行结果截图:
说明：当线程遇到I/O的时候还是运行状态。
下面在附上我画的状态转换图，一共只有六个状态。
我觉得以上两种理解方式只是站在同的角度去理解而已。
本文为作者原创，转载需要声明并且附上本文地址：http://www.cnblogs.com/GooPolaris/p/8079490.html