详细探究Java多线程的线程状态变化-阿里云开发者社区

2.1 线程状态

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中java.lang.Thread.State这个枚举中给出了六种线程状态：

这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析；

线程状态	导致状态发生条件
New(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

2.1.1 New

New：新建状态

表示线程被创建但尚未启动的状态：当我们用 new Thread() 新建一个线程时，如果线程没有开始运行 start() 方法，那么线程也就没有开始执行 run() 方法里面的代码，那么此时它的状态就是 New。而一旦线程调用了 start()，它的状态就会从 New 变成 Runnable

【示例代码】

package com.dfbz.demo01_线程的状态;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_线程状态_NEW {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
            }
        };
        // 线程未启动之前的状态都是NEW
        System.out.println(t1.getState());          // NEW
    }
}

2.1.2 Runnable

Runnable：可运行状态

一旦线程调用start()方法，线程就处于可运行状态（Runnable）。

一个可运行的线程能正在运行也可能没有运行。有些教科书上讲可运行状态分为了就绪状态和运行状态，即线程开启后进入就绪状态，当线程抢到CPU执行权后进入运行状态（Java规范没有将正在运行作为一个单独的状态，一个正在运行的线程仍然处于可运行状态）

【示例代码】

package com.dfbz.demo01_线程的状态;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_线程状态_RUNNABLE {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                while (true){
                }
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                while (true){
                }
            }
        };
        t1.start();
        t2.start();
        // 线程只要开启之后不管是否处于运行状态
        System.out.println(t1.getState());          // RUNNABLE
        System.out.println(t2.getState());          // RUNNABLE
    }
}

2.1.3 Blocked

Blocked：锁阻塞状态（在IDEA断点显示的MONITOR状态）

Blocked从 Runnable 状态进入到 Blocked 状态只有一种途径，那么就是当进入到 synchronized 代码块中时未能获得相应的锁，当有线程从 Blocked 状态指向了 Runnable ，也只有一种情况，那么就是当线程获得锁，此时线程就会进入 Runnable 状体中参与 CPU 资源的抢夺

【示例代码】

package com.dfbz.demo01_线程的状态;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_线程状态_BLOCKED {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                synchronized (Object.class) {
                    while (true) {
                    }
                }
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                // t2线程获取不到锁,被锁阻塞在外面
                synchronized (Object.class) {
                }
            }
        };
        t1.start();
        // 过一会再开启线程2(确保线程1必定先获取CPU执行权)
        Thread.sleep(10);
        t2.start();
        System.out.println(t1.getState());          // RUNNABLE
        System.out.println(t2.getState());          // BLOCKED
    }
}

2.1.4 Timed Waiting

Timed Waiting 状态，它与 Waiting 状态非常相似，其中的区别只在于是否有时间的限制，在 Timed Waiting 状态时会等待超时，之后由系统唤醒

在以下情况会让线程进入 Timed Waiting 状态。

线程执行了设置了时间参数的 Thread.sleep(long millis) 方法；
线程执行了设置了时间参数的 Object.wait(long timeout) 方法；
线程执行了设置了时间参数的 Thread.join(long millis) 方法；

通过这个我们可以进一步看到它与 waiting 状态的相同

【示例代码1-sleep】：

package com.dfbz.demo01_线程的状态;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo04_线程状态_TIMED_WAITING_01_sleep {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t1.start();
        // 让main线程睡眠一段时间(确保t1线程能够执行)
        Thread.sleep(100);
        System.out.println(t1.getState());          // TIMED_WAITING
    }
}

【示例代码2-wait】

package com.dfbz.demo01_线程的状态;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo05_线程状态_TIMED_WAITING_02_wait {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                synchronized (Object.class) {
                    while (true) {
                        try {
                            Object.class.wait(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        };
        t1.start();
        // 让main线程睡眠一段时间(确保t1线程能够执行)
        Thread.sleep(100);
        System.out.println(t1.getState());          // TIMED_WAITING
    }
}

【示例代码3-join】

package com.dfbz.demo01_线程的状态;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo06_线程状态_TIMED_WAITING_03_join {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                while (true) {
                }
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        // 让t1线程先执行10s,t2将处于TIMED_WAITING状态
                        t1.join(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
        t2.start();
        // 让main线程睡眠1s,保证t1线程能执行join方法
        Thread.sleep(1000);
        System.out.println(t1.getState());          // RUNNABLE
        System.out.println(t2.getState());          // TIMED_WAITING
    }
}

2.1.5 Waiting

对于 Waiting 状态的进入有3种情况，分别为：

1）当线程中调用了没有设置 Timeout 参数的 Object.wait() 方法
2）当线程调用了没有设置 Timeout 参数的 Thread.join() 方法
3）当线程调用了 LockSupport.park() 方法

【示例代码1-wait】：

package com.dfbz.demo01_线程的状态;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo07_线程状态_WAITING_01_wait {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                synchronized (Object.class) {
                    try {
                        Object.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
        // 让当前线程睡眠0.1s,确保t1线程能够执行wait
        Thread.sleep(100);
        System.out.println(t1.getState());          // WAITING
    }
}

【示例代码2-join】：

package com.dfbz.demo01_线程的状态;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo08_线程状态_WAITING_02_join {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                while (true){
                }
            }
        };
        Thread t2 = new Thread() {
            @Override
            public void run() {
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t1.start();
        t2.start();
        // 让当前线程睡眠0.1s,确保t1线程能够执行join
        Thread.sleep(100);
        System.out.println(t1.getState());          // RUNNABLE
        System.out.println(t2.getState());          // WAITING
    }
}

【示例代码3-park】：

package com.dfbz.demo01_线程的状态;
import java.util.concurrent.locks.LockSupport;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo09_线程状态_WAITING_03_park {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                while (true){
                    LockSupport.park();
                }
            }
        };
        t1.start();
        // 让当前线程睡眠0.1s,确保t1线程能够执行park
        Thread.sleep(100);
        System.out.println(t1.getState());          // WAITING
    }
}

Blocked与Waiting的区别：

Blocked 是在等待其他线程释放锁
Waiting 则是在等待某个条件，比如 join 的线程执行完毕，或者是 notify()/notifyAll() 。

2.1.6 Terminated

Terminated：终止状态，要想进入Terminated 状态有两种可能。

1）run() 方法执行完毕，线程正常退出。
2）出现一个没有捕获的异常，终止了 run() 方法，最终导致意外终止。

【示例代码】：

package com.dfbz.demo01_线程的状态;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo10_线程状态_TERMINATED {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("t1 running...");
            }
        };
        t1.start();
        // 让当前线程睡眠10毫秒,确保t1线程任务执行完毕
        Thread.sleep(10);
        System.out.println(t1.getState());          // TERMINATED
    }
}

2.2 线程状态变化

线程流程图：

接下来我们将来分析各自状态之间的转换，其实主要就是 Blocked、waiting、Timed Waiting 三种状态的转换，以及他们是如何进入下一状态最终进入 Runnable

2.2.1 Runnable与Blocked状态转换

1）Runnable状态进入Blocked状态：当前线程竞争锁对象失败时：Runnable-->Blocked
2）Blocked状态进入Runnable状态：当之前的线程释放了锁对象时，新的线程竞争到了锁对象时：Blocked-->Runnable

【示例代码】：

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_Runnable进入Blocked状态 {
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        Thread t1 = new Thread(() -> {
            while (true) {
                synchronized (obj) {
                    System.out.println("t1");
                }
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            while (true) {
                synchronized (obj) {
                    System.out.println("t2");
                }
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}

Tips：断点记得使用Thread模式；

2.2.2 Runnable与Waiting状态转换

Runnable状态与Waiting状态有三种情况，分别为wait、join、park；

1） Runnable转Waiting

Runnable状态进入Waiting状态：

1）调用wait方法
2）调用join方法
3）调用park方法

【示例代码-01-wait】

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_Runnable进入Waiting状态_01_wait {
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (obj) {
                System.out.println("t1-before..");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1-after..");
            }
        }, "t1");
        t1.start();
        // 确保t1线程先执行
        Thread.sleep(10);
        new Thread(() -> {
            synchronized (obj) {
                // 将所有线程都唤醒,唤醒的线程都将处于blocked状态,因为要等当前线程释放锁对象
                obj.notifyAll();
            }
        },"t2").start();
    }
}

分析：

【示例代码-02-join】

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_Runnable进入Waiting状态_02_join {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                while (true){
                }
            }
        };
        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                System.out.println("t2-before...");
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2-after...");
            }
        };
        t1.start();
        t2.start();
        // 让当前线程睡眠10ms,确保t1线程能够执行join
        Thread.sleep(10);
        System.out.println(t1.getState());          // RUNNABLE
        System.out.println(t2.getState());          // WAITING
    }
}

【示例代码-03-park】

package com.dfbz.demo02_线程状态的改变;
import java.util.concurrent.locks.LockSupport;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_Runnable进入Waiting状态_03_park {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                while (true){
                    System.out.println("t1-before");
                    System.out.println(Thread.currentThread().getState());
                    LockSupport.park();
                    System.out.println(Thread.currentThread().getState());
                    System.out.println("t1-after");
                }
            }
        };
        t1.start();
        // 确保t1线程先执行
        Thread.sleep(10);
        System.out.println(t1.getState());          // 使用断点让park方法先执行,此时线程状态为Waiting
    }
}

2） Waiting转Runnable

Waiting状态进入Runnable状态：

1）wait：

1）notifly或notifyAll方法（需要注意的是先进入Blocked再进入Runnable）进入Runnable状态
2）使用interrupt()中断线程（中断状态为false）

2）join：

1）等待join线程执行完毕
2）使用interrupt()中断线程（中断状态为false）

3）park：

1）调用unpark方法
2）使用interrupt()中断线程（并不会出现InterruptException，而且中断状态为true，相当于直接唤醒）

【示例代码Waiting转Runnable-01-wait-notify】

需要注意的是：如果一个线程处于 Waiting 状态，其他线程调用 notify() 或 notifyAll()来唤醒它，则它会直接进入 **Blocked** 状态，这里可能会有疑问，不是应该直接进入 Runnable 吗？

这里需要注意一点，如果调用 notify() 或 notifyAll()，要求该现场必须首先持有该锁，锁已经被该线程获取了，被唤醒的线程自然就获取不到锁，处于Blocked状态；直到执行了 notify()/notifyAll() 的线程执行完毕并释放锁，被唤醒的线程才可能轮到它去抢夺这把锁，如果它能抢到，就会从 Blocked 状态回到 Runnable 状态。

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo04_Waiting进入Runnable状态_01_wait_notify {
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (obj) {
                System.out.println("t1-before..");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1-after..");
            }
        }, "t1");
        t1.start();
        // 确保t1线程先执行
        Thread.sleep(10);
        new Thread(() -> {
            synchronized (obj) {
                // 将所有线程都唤醒,唤醒的线程都将处于blocked状态,因为要等当前线程释放锁对象
                obj.notifyAll();
            }
        },"t2").start();
    }
}

当我们通过 notify 唤醒线程时，被唤醒的线程是先进入锁阻塞状态的，再等抢夺到锁后才会进入 Runnable 状态

【示例代码Waiting转Runnable-02-wait-interrupt】

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo05_Waiting进入Runnable状态_02_wait_interrupt {
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (obj) {
                System.out.println("t1-before..");
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1-after..");
            }
        }, "t1");
        t1.start();
        // 确保t1线程先执行
        Thread.sleep(10);
        t1.interrupt();
    }
}

【示例代码Waiting转Runnable-03-join-join任务执行结束】

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo06_Waiting进入Runnable状态_03_join {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                // ③执行t1线程的run方法(将方法执行完毕)
                System.out.println("t1...");
            }
        };
        // ①首先t1开启线程(此时t1处于可运行状态)
        t1.start();
        // ②让t1线程执行join方法,此时main处于等待状态
        t1.join();
        // ④再次回到main方法,main从等待转换变为了可运行状态
        System.out.println("main");
    }
}

【示例代码Waiting转Runnable-04-join-interrupt】

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo07_Waiting进入Runnable状态_04_join_interrupt {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                System.out.println("t1...");
            }
        };
        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                System.out.println("t2-before...");
                try {
                    // ②让t1执行join方法,此时t2处于等待状态
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2-after...");
            }
        };
        // ①首先开启两个线程
        t1.start();
        t2.start();
        // ③t2执行interrupt方法,t2从等待状态变为可运行状态
        t2.interrupt();
    }
}

【示例代码Waiting转Runnable-05-wait-notify】

package com.dfbz.demo02_线程状态的改变;
import java.util.concurrent.locks.LockSupport;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo08_Waiting进入Runnable状态_05_park_unpark {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                while (true){
                    System.out.println("t1-before");
                    // ②让t1线程执行park(此时处于等待状态)
                    LockSupport.park();
                    System.out.println("t1-after");
                }
            }
        };
        // ①启动t1线程
        t1.start();
        // ③执行unpark方法,此时t1处于可运行状态
        LockSupport.unpark(t1);
        System.out.println("main end...");
    }
}

【示例代码Waiting转Runnable-06-wait-notify】

package com.dfbz.demo02_线程状态的改变;
import java.util.concurrent.locks.LockSupport;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo09_Waiting进入Runnable状态_06_park_interrupt {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                while (true){
                    System.out.println("t1-before");
                    // ②让t1线程执行park(此时处于等待状态)
                    LockSupport.park();
                    System.out.println("t1-after");
                }
            }
        };
        // ①启动t1线程
        t1.start();
        // ③执行interrupt方法,相当于唤醒t1线程,此时t1线程为可运行状态
        t1.interrupt();
        System.out.println("main end...");
    }
}

2.2.3 Runnable与Timed Waiting状态转换

1） Runnable转Timed Waiting

Runnable进入Timed Waiting：

1）线程执行了设置了时间参数的 Thread.sleep(long millis) 方法；
2）线程执行了设置了时间参数的 Object.wait(long timeout) 方法；
3）线程执行了设置了时间参数的 Thread.join(long millis) 方法；

2） Timed Waiting转Runnable

1）Thread.sleep(long millis) ：

1）等到millis时间到达
2）使用interrupt中断线程（中断状态还是false）

2）Object.wait(long timeout)：

1）等到timeout时间到达
2）使用interrupt中断线程（中断状态还是false）
3）使用notifly或notiflyAll唤醒（首先进入Blocked状态，竞争到锁之后再进入Runnable状态）

3）Thread.join(long millis)：

1）等到timeout时间到达
2）使用interrupt中断线程（中断状态还是false）
3）使用notifly或notiflyAll唤醒（首先进入Blocked状态，竞争到锁之后再进入Runnable状态）

Tips：notifly和notiflyAll只能唤醒使用wait方法进行等待的线程；

【示例代码1】：

1）测试sleep方法时间到达后线程状态从Timed Waiting变为Runnable

2）测试调用interrupt()方法将线程状态从Timed Waiting变为Runnable

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo10_Runnable与TimedWaiting状态_01_sleep {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                System.out.println("t1-before...");
                try {
                    // ②线程睡眠(从可运行变为了计时等待),当睡眠时间结束后自动从计时等待变为可运行状态
                    Thread.sleep(1000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t1-after...");
            }
        };
        // ①开启线程
        t1.start();
        // ③调用interrupt中断计时等待状态的线程,t1从计时等待变为了可运行状态
        t1.interrupt();
    }
}

分析：

【示例代码2-1】：

1）测试wait方法时间到达后线程状态从Timed Waiting变为Runnable

2）测试调用interrupt()方法将线程状态从Timed Waiting变为Runnable

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo03_Runnable与TimedWaiting状态_02_wait方法 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                synchronized (Object.class){
                    System.out.println("t1-before...");
                    try {
                        // 等到wait的时间到达之后线程自动从Timed Waiting状态变为Runnable状态
                        Object.class.wait(30000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t1-after...");
                }
            }
        };
        t1.start();
        // 确保t1线程先执行
        Thread.sleep(10);
        // 中断之前t1的状态为Timed Waiting,中断之后t1的状态为Runnable
        t1.interrupt();
    }
}

需要注意的是，在IDEA中，只要调用wait方法，那么IDEA在调试窗口中就会线程该线程为WAIT，但此时这个线程是计时等待状态，我们可以通过右键菜单--->Evaluate Expression...，查看t1的状态：

【示例代码2-2】：使用notify/notiflyAll将线程状态从Timed Waiting变为Runnable（Blocked）

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo12_Runnable与TimedWaiting状态_03_wait_notify {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                synchronized (Object.class){
                    System.out.println("t1-before...");
                    try {
                        // ②执行wait方法(从可运行变为了计时等待),如果时间结束,那么线程自动进入可运行状态
                        // 注意: 调用wait方法会释放锁
                        Object.class.wait(30000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t1-after...");
                }
            }
        };
        // ①开启线程
        t1.start();
        synchronized (Object.class){
            // ③执行notify方法,把t1唤醒,t1从计时等待变为了锁阻塞状态
            // 唤醒之前t1的状态为Timed Waiting,唤醒之后t1的状态为Blocked,等到t1线程获取到锁之后状态为Runnable
            Object.class.notify();
        }
    }
}

【示例代码3】：

1）测试join方法时间到达后线程状态从Timed Waiting变为Runnable

2）测试调用interrupt()方法将线程状态从Timed Waiting变为Runnable

package com.dfbz.demo02_线程状态的改变;
/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo13_Runnable与TimedWaiting状态_04_join {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                while (true){}
            }
        };
        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                try {
                    // ②执行join方法(t2从可运行变为了计时等待),如果时间结束,那么线程自动进入可运行状态
                    t1.join(3000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("t2-after..");
            }
        };
        // ①开启t1、t2线程
        t1.start();
        t2.start();
        // ③调用interrupt中断计时等待状态的线程(中断状态为false),t2从计时等待变为了可运行状态
        t2.interrupt();
    }
}

2.2.2 状态变化的注意事项

1）线程从 New 状态是不可以直接进入 Blocked 状态的，它需要先经历 Runnable 状态。
2）线程生命周期不可逆，一旦进入 Runnable 状态就不能回到 New 状态；一旦被终止就不可能再有任何状态的变化。
3）所以一个线程只能有一次 New 和 Terminated 状态，只有处于中间状态才可以相互转换。也就是这两个状态不会参与相互转化

详细探究Java多线程的线程状态变化

2.1 线程状态

2.1.1 New

2.1.2 Runnable

2.1.3 Blocked

2.1.4 Timed Waiting

2.1.5 Waiting

2.1.6 Terminated

2.2 线程状态变化

2.2.1 Runnable与Blocked状态转换

2.2.2 Runnable与Waiting状态转换

1） Runnable转Waiting

2） Waiting转Runnable

2.2.3 Runnable与Timed Waiting状态转换

1） Runnable转Timed Waiting

2） Timed Waiting转Runnable

2.2.2 状态变化的注意事项

热门文章

最新文章

相关课程

相关电子书

相关实验场景