Java 中的线程有 6 种状态
// java.lang.Thread
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
//这些状态是虚拟机状态,它不反映任何操作系统的线程状态。
新建(NEW)
新创建了一个线程对象,还未调用 start()
方法。
public class Main {
public static void main(String[] args) {
Thread threadA = new Thread("threadA");
System.out.println(threadA.getState()); // NEW
}
}
可运行(RUNNABLE)
线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取cpu 的使用权(时间片) 。
RUNNABLE 在 Java 中就是运行状态的标识。但它可能正在等待来自于操作系统的其它资源,比如处理器。
public class Main {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < Integer.MAX_VALUE; i++) {
System.out.println(i);
}
}
}, "RUNNABLE-Thread");
thread.start();
}
}
等待(WAITING)
运行中(Running)的线程执行了4个方法中的任意方法:
- Object 的
wait()
方法,并且没有使用 timeout 参数 - Thread 的
join()
方法,没有使用 timeout 参数 - LockSupport 的
park()
方法 - Condition 的
await()
方法
处于WAITING状态的线程会等待另外一个线程处理特殊的行为。 举个例子,如果一个线程调用了一个对象的wait方法,那么这个线程就会处于waiting状态直到另外一个线程调用这个对象的notify或者notifyAll方法后才会解除这个状态
public class Main {
public static void main(String[] args) {
Object o = new Object();
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
synchronized (o) {
try {
o.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "threadA");
threadA.start();
}
}
有时间等待(TIMED_WAITING)
有等待时间的等待状态,比如调用了以下几个方法中的任意方法,并且指定了等待时间,线程就会处于这个状态。
- Thread.sleep 方法
- Object的 wait 方法,带有时间
- Thread.join 方法,带有时间
- LockSupport 的 parkNanos 方法,带有时间
- LockSupport 的 parkUntil 方法,带有时间
public class Main {
public static void main(String[] args) {
Object o = new Object();
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
synchronized (o) {
try {
o.wait(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "threadA");
threadA.start();
}
}
阻塞(BLOCKED)
阻塞状态是指线程因为某种原因放弃了cpu 使用权,暂时停止运行。直到线程进入可运行(RUNNABLE)状态,才有机会再次获得cpu timeslice 转到运行(running)状态。
阻塞的情况分两种:
- 同步阻塞:运行(running)的线程进入了一个
synchronized
方法,若该同步锁被别的线程占用,则JVM会把该线程放入锁池(lock pool)中。 - 其他阻塞:运行(running)的线程发出了I/O请求时,JVM会把该线程置为阻塞状态。当I/O处理完毕时,线程重新转入可运行(RUNNABLE)状态。
public class Main {
public static void main(String[] args) {
Object lock = new Object();
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
System.out.println(Thread.currentThread().getName() + " invoke");
try {
Thread.sleep(20000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "BLOCKED-Thread-A");
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock) {
System.out.println(Thread.currentThread().getName() + " invoke");
try {
Thread.sleep(20000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "BLOCKED-Thread-B");
threadA.start();
threadB.start();
}
}
线程A和线程B都需要持有lock对象的锁才能调用方法。如果线程A持有锁,那么线程B处于BLOCKED状态;如果线程B持有锁,那么线程A处于BLOCKED状态。
死亡(TERMINATED)
线程的run()
、main()
方法执行结束,或者因异常退出了run()
方法,则该线程结束生命周期。并且死亡的线程不可再次复生。
Thread threadA = new Thread();
threadA.start();
try {
Thread.sleep(5000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadA.getState()); // TERMINATED
- RUNNABLE,对应"就绪"和"运行"两种状态,也就是说处于就绪和运行状态的线程在
java.lang.Thread
中都表现为"RUNNABLE" - BLOCKED,对应"阻塞"状态,此线程需要获得某个锁才能继续执行,而这个锁目前被其他线程持有,所以进入了被动的等待状态,直到抢到了那个锁,才会再次进入"就绪"状态。
- WAITING,对应"阻塞"状态,代表此线程正处于无限期的主动等待中,直到有人唤醒它,它才会再次进入就绪状态
- TIMED_WAITING,对应"阻塞"状态,代表此线程正处于有限期的主动等待中,要么有人主动唤醒它,要么等待够了一定时间之后,才会再次进入就绪状态。
BLOCKED 与 WAITING的区别?
BLOCKED是指线程正在等待获取锁;WAITING是指线程正在等待其他线程发来的通知(notify),收到通知后,可能会顺序向后执行(RUNNABLE),也可能会再次获取锁,进而被阻塞住(BLOCKED)。
Thread.sleep() 与 Object.wait() 最重要的区别就是:
sleep()
在执行时,保持对象锁。
而wait()
在执行时,释放对象锁。
另外:
- wait, notify 和 notifyAll 只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用。
Thread.yield()
译为线程让步,就是说当一个线程使用了这个方法之后,它会把自己 CPU 执行时间(时间片)让掉,让自己或者其它的线程运行,注意是让自己或者其他线程运行,并不是单纯的让给其他线程。
它能让当前线程由“运行状态”进入到“就绪状态”,从而让其它具有相同优先级的等待线程获取执行权;但是,并不能保证在当前线程调用 yield() 之后,其它具有相同优先级的线程就一定能获得执行权;也有可能是当前线程又进入到“运行状态”继续运行!
举个例子:一帮朋友在排队上公交车,轮到 Yield 的时候,他突然说:我不想先上去了,咱们大家来竞赛上公交车。然后所有人就一块冲向公交车,有可能是其他人先上车了,也有可能是 Yield 先上车了。
但是线程是有优先级的,优先级越高的人,就一定能第一个上车吗?这是不一定的,优先级高的人仅仅只是第一个上车的概率大了一点而已,最终第一个上车的,也有可能是优先级最低的人。并且所谓的优先级执行,是在大量执行次数中才能体现出来的。
A hint to the scheduler that the current thread is willing to yield its current use of a processor. The scheduler is free to ignore this hint.
查看 API 可以看到,线程调度器可以忽略该方法。
参考:
https://fangjian0423.github.io/2016/06/04/java-thread-state/
http://www.cnblogs.com/dolphin0520/p/3920357.html
https://www.zhihu.com/question/56494969
https://www.uml-diagrams.org/java-thread-uml-state-machine-diagram-example.html