图文详解jvm中的线程状态

本文使用下面这张图详细介绍JAVA线程的六种状态

            JAVA线程的六种状态详解

在java.lang.Thread类中，定义了线程的以下六种状态(同一个时刻线程只能有一种状态)

NEW（新建） 这个状态是指线程刚创建，但还未调用线程的start()方法进行启动，对应上图中的New状态

RUNNABLE（可运行） 这个状态是指线程处于正常运行中，对应上图中的Runnable与Running状态，若获得CPU时间片则处于Running状态，否则处于Runnable状态

BLOCKED（阻塞）这个状态是指当线程进入一个被synchronized修饰的方法或语句块（也叫临界区）时，如果锁已被其他线程所获取，则会进入此状态。对应上图中的锁定Blocked状态

WAITING（无限等待）这个状态是指当线程获取到对象锁进入临界区内，调用了锁对象的wait()方法或者thread.join()方法后进入的状态。线程进入该状态会释放锁对象，并且等待被其他的线程所唤醒，处于这种状态的线程不会被分配CPU时间片。该状态对应上图中的等待Blocked状态

TIMED_WAITING（有限等待） 这个状态是指当线程调用了以下方法后进入的状态。在指定时间后由系统将它们自动唤醒，处于这种状态的线程不会被分配CPU时间片。该状态对应上图中的Blocked状态

1.Thread.sleep()方法

2.Object.wait()方法（有timeout参数）

3.thread.join()方法（有timeout参数）

TERMINATED（死亡） 这个状态是指run()方法已执行完毕，线程进入死亡状态

            JAVA线程状态切换详解

1.NEW状态

当我们new一个线程，但还未调用线程的start()方法时，线程为NEW状态，使用thread.getState()方法可以获取线程状态，如下这段代码：

public class Test {public static void main(String[] args) {Thread t1 = new Thread(new Task1());System.out.println(t1.getState());}
}class Task1 implements Runnable {@Overridepublic void run() {System.out.println();}
}

程序执行结果：

2.RUNNABLE状态

当线程调用start()方法后进入该状态，对应上图中New状态向Runnable状态的转变。但是注意，这不代表线程马上就开始运行程序，此时线程需要等待CPU给它分配时间片，分配到了CPU时间片才算是真正意义上的程序执行（对应上图中Runnable状态向Running状态的转变），CPU时间片执行完毕后线程需要等待CPU下一次给它分配CPU时间片（对应上图中Running状态向Runnable状态的转变）。

当线程获得CPU时间片并正在执行程序时，如果此时线程调用yield()方法，线程会让出当前CPU时间片，并与其他线程一起竞争下一次的CPU时间片（有可能下一次的CPU时间片还是被该线程获得）

public class Test {public static void main(String[] args) {Thread t1 = new Thread(new Task1());t1.start();System.out.println(t1.getState());}
}class Task1 implements Runnable {@Overridepublic void run() {System.out.println();}
}

程序执行结果：

3.BLOCKED状态

当线程分配到CPU时间片并在执行程序时，假如此时需要进入一个synchronized方法或语句块，但是锁对象正在被其它线程所使用，而无法获取锁进入临界区，此时线程进入entry set区，状态为BLOCKED。对应上图中由Running状态向锁定Blocked状态的转变。如下这段代码：当线程t1获取test对象锁后执行blockTest()方法，此时t2线程进入test对象的entry set区，等待t1线程释放锁后竞争锁资源，此时t2线程的状态为BLOCKED

public class Test {public static void main(String[] args) {Test test = new Test();Thread t1 = new Thread(new Task1(test));Thread t2 = new Thread(new Task2(test));t1.start();t2.start();try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("t1:" + t1.getState());System.out.println("t2:" + t2.getState());}public void blockTest() {synchronized (this) {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}}
}class Task1 implements Runnable {private Test test;public Task1(Test test) {this.test = test;}@Overridepublic void run() {test.blockTest();}
}class Task2 implements Runnable {private Test test;public Task2(Test test) {this.test = test;}@Overridepublic void run() {test.blockTest();}
}

程序执行结果：

4.WAITING状态

当线程在临界区内执行程序，此时如果执行的代码为对象锁的wait()方法或thread.join方法时，线程将释放锁，并且进入wait set区，等待被其它线程所唤醒，线程状态由RUNNABLE转变为WAITING（对应上图的Running状态转变为等待Blocked状态）。下面第一段代码说明线程执行临界区中锁对象的wait方法时，线程状态的变化，此时由于没有其它线程去唤醒该线程，所以该线程的状态会一直保持在waiting状态。下面第二段代码说明线程t2在执行t1.join()方法后由RUNNABLE状态转变为WAITING状态，等到t1线程的run方法执行完线程t2再执行，线程的join方法底层也是由wait()方法来实现的

当其它线程调用该对象的notify或notifyAll方法后，该线程被唤醒，并由wait set区进入entry set区，线程状态由WAITING转变为BLOCKED（对应上图中的等待Blocked转变为锁定Blocked）。如下面第三段代码，线程t1获取test对象的对象锁后进入临界区，当执行锁对象的wait()方法后释放锁，并进入WAITING状态，接着线程t2获取该对象锁并调用notify方法唤醒线程t1，唤醒后的线程t1由于没有其它线程与它竞争test对象的锁资源，所以跳过BLOCKED状态，直接获取对象锁执行之后代码，此时t1状态为Runnable。

public class Test {public static void main(String[] args) {Test test = new Test();Thread t1 = new Thread(new Task1(test));t1.start();try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("t1等待:" + t1.getState());}public void waitTest() {synchronized (this) {System.out.println("t1运行:" + Thread.currentThread().getState());try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}}
}class Task1 implements Runnable {private Test test;public Task1(Test test) {this.test = test;}@Overridepublic void run() {test.waitTest();}
}

程序执行结果：

public class Test {public static void main(String[] args) {Thread t1 = new Thread(new Task1());Thread t2 = new Thread(new Task2(t1));t1.start();t2.start();try {System.out.println("t2运行:" + t2.getState());Thread.sleep(1000);System.out.println("t2等待:" + t2.getState());} catch (InterruptedException e) {e.printStackTrace();}}}class Task1 implements Runnable {@Overridepublic void run() {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}
}class Task2 implements Runnable {private Thread thread;public Task2(Thread thread) {this.thread = thread;}@Overridepublic void run() {try {for (int i = 0; i < 10000; i++) {}thread.join();} catch (InterruptedException e) {e.printStackTrace();}}
}

程序执行结果：

public class Test {public static void main(String[] args) {Test test = new Test();Thread t1 = new Thread(new Task1(test));Thread t2 = new Thread(new Task2(test));t1.start();t2.start();try {Thread.sleep(1000);System.out.println("t1等待:" + t1.getState());} catch (InterruptedException e) {e.printStackTrace();}}public void waitTest() {System.out.println("t1运行:" + Thread.currentThread().getState());synchronized (this) {try {this.wait();System.out.println("t1唤醒后运行:"+ Thread.currentThread().getState());} catch (InterruptedException e) {e.printStackTrace();}}}public void notifyTest() {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (this) {this.notify();}}
}class Task1 implements Runnable {private Test test;public Task1(Test test) {this.test = test;}@Overridepublic void run() {test.waitTest();}}class Task2 implements Runnable {private Test test;public Task2(Test test) {this.test = test;}@Overridepublic void run() {test.notifyTest();}
}

程序执行结果：

5.TIMED_WAITING状态

当线程分配到CPU时间片并在执行程序时，此时执行到的语句为线程的sleep()方法或对象的wait()方法（有timeout参数）或线程的join()方法（有timeout参数）时，线程由RUNNABLE状态转变为TIMED_WAITING状态（对应上图中的Running状态转变为Blocked状态）。下面第一段代码说明线程t1调用sleep()方法后进入TIMED_WAITING状态，休眠时间过去后重新转为RUNNABLE状态，另外sleep()方法是不释放锁的。第二段代码说明线程t1调用test对象的wait方法后进入TIMED_WAITING状态，等待时间过去后重新转为RUNNABLE状态，因为该wait()方法设置了等待时间，所以不需要通过其它线程来唤醒，等待时间过去后由系统自动唤醒该线程，另外wait()方法是释放锁的。第三段代码说明线程t2调用了线程t1的join方法后进入TIMED_WAITING状态，等待时间过去后重新转为RUNNABLE状态，join()方法底层也是通过wait()方法实现的

public class Test {public static void main(String[] args) {Thread t1 = new Thread(new Task1());t1.start();try {System.out.println("t1运行:" + t1.getState());Thread.sleep(1000);System.out.println("t1等待:" + t1.getState());} catch (InterruptedException e) {e.printStackTrace();}}
}class Task1 implements Runnable {@Overridepublic void run() {try {for (int i = 0; i < 10000; i++) {}Thread.sleep(3000);System.out.println("t1重新运行" + Thread.currentThread().getState());} catch (InterruptedException e) {e.printStackTrace();}}
}

程序执行结果：

public class Test {public static void main(String[] args) {Test test = new Test();Thread t1 = new Thread(new Task1(test));t1.start();try {System.out.println("t1运行:" + t1.getState());Thread.sleep(1000);System.out.println("t1等待:" + t1.getState());} catch (InterruptedException e) {e.printStackTrace();}}public void waitTest() {synchronized (this) {try {this.wait(3000);} catch (InterruptedException e) {e.printStackTrace();}}}
}class Task1 implements Runnable {private Test test;public Task1(Test test) {this.test = test;}@Overridepublic void run() {for (int i = 0; i < 10000; i++) {}test.waitTest();System.out.println("t1重新运行：" + Thread.currentThread().getState());}
}

程序执行结果：

public class Test {public static void main(String[] args) {Thread t1 = new Thread(new Task1());Thread t2 = new Thread(new Task2(t1));t1.start();t2.start();try {System.out.println("t2运行:" + t2.getState());Thread.sleep(1000);System.out.println("t2等待:" + t2.getState());} catch (InterruptedException e) {e.printStackTrace();}}}class Task1 implements Runnable {@Overridepublic void run() {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}
}class Task2 implements Runnable {private Thread thread;public Task2(Thread thread) {this.thread = thread;}@Overridepublic void run() {try {for (int i = 0; i < 10000; i++) {}thread.join(3000);System.out.println("t2重新运行：" + Thread.currentThread().getState());} catch (InterruptedException e) {e.printStackTrace();}}
}

程序执行结果：

5.TERMINATED状态

当线程运行完run()方法后，就转变为此状态。如下代码说明了线程由RUNNABLE状态转变为TERMINATED状态（对应上图Running状态向Dead状态的转变）

public class Test {public static void main(String[] args) {Thread t1 = new Thread(new Task1());t1.start();try {System.out.println("t1运行:" + t1.getState());Thread.sleep(3000);System.out.println("t1死亡:" + t1.getState());} catch (InterruptedException e) {e.printStackTrace();}}
}class Task1 implements Runnable {@Overridepublic void run() {for (int i = 0; i < 10000; i++) {}}
}

程序执行结果：