java线程阻塞 挂起_Java中一个线程只有六个状态。至于阻塞、可运行、挂起状态都是人们为了便于理解，自己加上去的。...

java中，线程的状态使用一个枚举类型来描述的。这个枚举一共有6个值: NEW(新建)、RUNNABLE(运行)、BLOCKED(锁池)、TIMED_WAITING(定时等待)、WAITING(等待)、TERMINATED(终止、结束)。

但是我发现大多数人的理解和上面的这六种还是有些差别，通常会加上阻塞状态，可运行状态，挂起状态。

这是Thread类描述线程状态的枚举类的源代码：

public enumState {/*** 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

* {@linkObject#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:

*

*

{@linkObject#wait() Object.wait} with no timeout

*

{@link#join() Thread.join} with no timeout

*

{@linkLockSupport#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}

*

{@linkObject#wait(long) Object.wait} with timeout

*

{@link#join(long) Thread.join} with timeout

*

{@linkLockSupport#parkNanos LockSupport.parkNanos}

*

{@linkLockSupport#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 classTest1

{public static voidmain(String[] args)

{

Thread1 t1= newThread1();

Thread2 t2= newThread2();

t1.setThread2(t2);

t1.start();

t2.start();

}

}//Thread1负责打印两个线程的状态。

class Thread1 extendsThread

{privateThread2 t2;public voidsetThread2(Thread2 t2)

{this.t2 =t2;

}

@Overridepublic voidrun()

{

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 extendsThread

{

@Overridepublic voidrun()

{

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 classTest1

{public static voidmain(String[] args)

{

Thread1 t1= newThread1();

Thread2 t2= newThread2();

Thread3 t3= newThread3();//t1需要持有t2,t3的引用，以便打印他们的状态。

t1.setThread2(t2,t3);//t2需要持有t3的引用，以便t3能够在t2执行时加入(调用join()方法)

t2.setTh3(t3);

t1.start();

t2.start();

}

}//Thread1负责打印所有线程的状态。

class Thread1 extendsThread

{privateThread2 t2;privateThread3 t3;public voidsetThread2(Thread2 t2, Thread3 t3)

{this.t2 =t2;this.t3 =t3;

}

@Overridepublic voidrun()

{

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 extendsThread

{privateThread3 t3;public voidsetTh3(Thread3 t3)

{this.t3 =t3;

}//当进入t2线程以后马上启动t3线程并调用join()方法。

@Overridepublic voidrun()

{

System.out.println("进入t2线程，t3准备加入(调用join()方法)");

t3.start();try{

t3.join();

}catch(InterruptedException e)

{

e.printStackTrace();

}

System.out.println("t2执行结束");

}

}class Thread3 extendsThread

{

@Overridepublic voidrun()

{

System.out.println("进入t3线程，准备睡眠");//本来是想让t3线程做加法运算的，奈何电脑算太快了，所以改为睡眠。因为睡眠不释放锁，所以效果一样。

try{

sleep(5000);

}catch(InterruptedException e)

{

e.printStackTrace();

}

System.out.println("t3线程结束");

}

}

这是运行的打印结果，当t3加入后t2处于等待状态

根据结果看，说明当一个正在执行的线程在其他线程调用join()方法以后进入了等待状态。

证明三：当一个线程调用了suspend()方法的时候它还是运行状态(RUNNABLE)。

packagecom.zcd.observe;public classTest1

{public static voidmain(String[] args)

{

Thread1 t1= newThread1();

Thread2 t2= newThread2();//t1需要持有t2,以便打印状态，和控制它恢复运行。

t1.setThread2(t2);

t1.start();

t2.start();

}

}//Thread1负责打印所有线程的状态。

class Thread1 extendsThread

{privateThread2 t2;public voidsetThread2(Thread2 t2)

{this.t2 =t2;

}

@Overridepublic voidrun()

{

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 extendsThread

{

@Overridepublic voidrun()

{

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的时候还是运行状态。

packagecom.zcd.observe;importjava.util.Scanner;public classTest1

{public static voidmain(String[] args)

{

Thread1 t1= newThread1();

Thread2 t2= newThread2();

t1.setThread2(t2);

t1.start();

t2.start();

}

}//Thread1负责打印所有线程的状态。

class Thread1 extendsThread

{privateThread2 t2;public voidsetThread2(Thread2 t2)

{this.t2 =t2;

}

@Overridepublic voidrun()

{

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 extendsThread

{

@Overridepublic voidrun()

{

System.out.println("进入t2线程");//让线程进入I/O

System.out.println("请输入数据：");

Scanner scan= newScanner(System.in);

String read=scan.nextLine();

System.out.println("您输入的数据为："+read);

System.out.println("t2线程结束");

}

}

执行结果截图:

说明：当线程遇到I/O的时候还是运行状态。

下面在附上我画的状态转换图，一共只有六个状态。

我觉得以上两种理解方式只是站在同的角度去理解而已。