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
【示例代码】
代码语言：javascript复制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规范没有将正在运行作为一个单独的状态，一个正在运行的线程仍然处于可运行状态）
【示例代码】
代码语言：javascript复制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 资源的抢夺
【示例代码】
代码语言：javascript复制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】：
代码语言：javascript复制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】
代码语言：javascript复制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】
代码语言：javascript复制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】：
代码语言：javascript复制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】：
代码语言：javascript复制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】：
代码语言：javascript复制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() 方法，最终导致意外终止。
【示例代码】：
代码语言：javascript复制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
【示例代码】：
代码语言：javascript复制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】
代码语言：javascript复制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】
代码语言：javascript复制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】
代码语言：javascript复制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 状态。
代码语言：javascript复制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】
代码语言：javascript复制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任务执行结束】
代码语言：javascript复制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】
代码语言：javascript复制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】
代码语言：javascript复制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】
代码语言：javascript复制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
代码语言：javascript复制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
代码语言：javascript复制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）
代码语言：javascript复制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
代码语言：javascript复制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 状态，只有处于中间状态才可以相互转换。也就是这两个状态不会参与相互转化
