目录
- 1. 五种状态
- 2. 六种状态
- 根据 Thread.State 枚举，分为六种状态
- 验证Java中的状态
- 不同情况再来分析一下Java种的六种状态的转变
- 情况 1 `NEW --> RUNNABLE`
- 情况 2 `RUNNABLE <--> WAITING`
- 情况 3 `RUNNABLE <--> WAITING`
- 情况 4 `RUNNABLE <--> WAITING`
- 情况 5 `RUNNABLE <--> TIMED_WAITING`
- 情况 6 `RUNNABLE <--> TIMED_WAITING`
- 情况 7 `RUNNABLE <--> TIMED_WAITING`
- 情况 8 `RUNNABLE <--> TIMED_WAITING`
- 情况 9 `RUNNABLE <--> BLOCKED`
- 情况 10 `RUNNABLE <--> TERMINATED`
1. 五种状态
这是从 操作系统 层面来描述的
- 【创建状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
- 【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
- 【运行状态】指获取了 CPU 时间片运行中的状态
- 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
- 【阻塞状态】
- 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入 【阻塞状态】
- 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
- 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑 调度它们
- 【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态
状态转换条件：
- 就绪态→运行态：处于就绪态的进程被调度后，获得处理机资源（分派处理机时间片），于是进程由就绪态转换为运行态。
- 运行态→就绪态：处于运行态的进程在时间片用完后，不得不让出处理机，从而进程由运行态转换为就绪态。此外，在可剥夺的操作系统中，当有更高优先级的进程就绪时，调度程序将正在执行的进程转换为就绪态，让更高优先级的进程执行。
- 运行态→阻塞态：进程请求某一资源（如外设）的使用和分配或等待某一事件的发生（如 I/O 操作的完成）时，它就从运行态转换为阻塞态。进程以系统调用的形式请求操作系统提供服务，这是一种由运行用户态程序调用操作系统内核过程的形式。
- 阻塞态→就绪态：进程等待事件到来时，如 I/O 操作结束或中断结束时，中断处理程序必须把相应进程的状态由阻塞态转换为就绪态。
2. 六种状态
这是从 Java API 层面来描述的
根据 Thread.State 枚举，分为六种状态
- NEW 线程刚被创建，但是还没有调用 start() 方法
- RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的 【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为 是可运行）
- BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节 详述
- TERMINATED 当线程代码运行结束
Thread.State是一个内部枚举类，定义了6个枚举常量：
public enum State {
// 新建状态
NEW,
// 运行状态
RUNNABLE,
/**
* 阻塞状态
* Object.wait
*/
BLOCKED,
/**
* 等待状态
* Object.wait
* Thread.join
* LockSupport.park
*/
WAITING,
/**
* 限时等待状态
* Thread.sleep
* Object.wait
* Thread.join
* LockSupport.parkUntil
* LockSupport.parkNanos
*/
TIMED_WAITING,
// 终止状态
TERMINATED;
}
验证Java中的状态
@Slf4j(topic = "c.threadState")
public class ThreadState {
public static void main(String[] args) throws IOException {
Thread t1 = new Thread("t1") {
@Override
public void run() {
log.debug("running...");
}
};
Thread t2 = new Thread("t2") {
@Override
public void run() {
while(true) { // runnable
}
}
};
t2.start();
Thread t3 = new Thread("t3") {
@Override
public void run() {
log.debug("running...");
}
};
t3.start();
Thread t4 = new Thread("t4") {
@Override
public void run() {
synchronized (ThreadState.class) {
try {
Thread.sleep(1000000); // timed_waiting
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
t4.start();
Thread t5 = new Thread("t5") {
@Override
public void run() {
try {
t2.join(); // waiting
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
t5.start();
Thread t6 = new Thread("t6") {
@Override
public void run() {
synchronized (ThreadState.class) { // blocked
try {
Thread.sleep(1000000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
t6.start();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("t1 state {}", t1.getState());
log.debug("t2 state {}", t2.getState());
log.debug("t3 state {}", t3.getState());
log.debug("t4 state {}", t4.getState());
log.debug("t5 state {}", t5.getState());
log.debug("t6 state {}", t6.getState());
System.in.read();
}
}
输出：
17:46:11.509 [t3] DEBUG c.threadState - running...
17:46:12.008 [main] DEBUG c.threadState - t1 state NEW
17:46:12.016 [main] DEBUG c.threadState - t2 state RUNNABLE
17:46:12.017 [main] DEBUG c.threadState - t3 state TERMINATED
17:46:12.017 [main] DEBUG c.threadState - t4 state TIMED_WAITING
17:46:12.017 [main] DEBUG c.threadState - t5 state WAITING
17:46:12.017 [main] DEBUG c.threadState - t6 state BLOCKED
不同情况再来分析一下Java种的六种状态的转变
假设有线程
Thread t
情况 1 NEW --> RUNNABLE
- 当调用
t.start()方法时，由 NEW --> RUNNABLE
情况 2 RUNNABLE <--> WAITING
t 线程用 synchronized(obj) 获取了对象锁后
- 调用
obj.wait()方法时，t 线程从RUNNABLE --> WAITING - 调用
obj.notify()，obj.notifyAll()，t.interrupt()时- 竞争锁成功，t 线程从
WAITING --> RUNNABLE - 竞争锁失败，t 线程从
WAITING --> BLOCKED
- 竞争锁成功，t 线程从
public class TestWaitNotify {
final static Object obj = new Object();
public static void main(String[] args) {
new Thread(() -> {
synchronized (obj) {
log.debug("执行....");
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("其它代码...."); // 断点
}
},"t1").start();
new Thread(() -> {
synchronized (obj) {
log.debug("执行....");
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug("其它代码...."); // 断点
}
},"t2").start();
TimeUnit.MILLISECONDS.sleep(500);
log.debug("唤醒 obj 上其它线程");
synchronized (obj) {
obj.notifyAll(); // 唤醒obj上所有等待线程 断点
}
}
}
情况 3 RUNNABLE <--> WAITING
- 当前线程调用
t.join()方法时，当前线程从RUNNABLE --> WAITING注意是当前线程在t 线程对象的监视器上等待 - t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从
WAITING --> RUNNABLE
情况 4 RUNNABLE <--> WAITING
- 当前线程调用
LockSupport.park()方法会让当前线程从RUNNABLE --> WAITING - 调用
LockSupport.unpark(目标线程) 或调用了线程 的interrupt()，会让目标线程从WAITING --> RUNNABLE
情况 5 RUNNABLE <--> TIMED_WAITING
t 线程用 synchronized(obj) 获取了对象锁后
- 调用
obj.wait(long n)方法时，t 线程从RUNNABLE --> TIMED_WAITING - t 线程等待时间超过了 n 毫秒，或调用
obj.notify()，obj.notifyAll()，t.interrupt()时- 竞争锁成功，t 线程从
TIMED_WAITING --> RUNNABLE - 竞争锁失败，t 线程从
TIMED_WAITING --> BLOCKED
- 竞争锁成功，t 线程从
情况 6 RUNNABLE <--> TIMED_WAITING
- 当前线程调用
t.join(long n)方法时，当前线程从RUNNABLE --> TIMED_WAITING注意是当前线程在t 线程对象的监视器上等待 - 当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的
interrupt()时，当前线程从TIMED_WAITING --> RUNNABLE
情况 7 RUNNABLE <--> TIMED_WAITING
- 当前线程调用
Thread.sleep(long n)，当前线程从RUNNABLE --> TIMED_WAITING - 当前线程等待时间超过了 n 毫秒，当前线程从
TIMED_WAITING --> RUNNABLE
情况 8 RUNNABLE <--> TIMED_WAITING
- 当前线程调用
LockSupport.parkNanos(long nanos)或LockSupport.parkUntil(long millis)时，当前线程从RUNNABLE --> TIMED_WAITING - 调用
LockSupport.unpark(目标线程) 或调用了线程 的interrupt()，或是等待超时，会让目标线程从TIMED_WAITING--> RUNNABLE
情况 9 RUNNABLE <--> BLOCKED
- t 线程用
synchronized(obj)获取了对象锁时如果竞争失败，从RUNNABLE --> BLOCKED - 持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有
BLOCKED的线程重新竞争，如果其中 t 线程竞争 成功，从BLOCKED --> RUNNABLE，其它失败的线程仍然BLOCKED
情况 10 RUNNABLE <--> TERMINATED
- 当前线程所有代码运行完毕，进入
TERMINATED
470
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
