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