本文详细解析Java线程的六种状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING及TERMINATED，阐述每种状态的特点与应用场景，并探讨线程状态之间的转换机制。
1. 线程的6种状态
Java线程Thread在package java.lang;中可以找到，通过源码，我们可以看到其状态有如下6种
- NEW
- RUNNABLE
- BLOCKED
- WAITING
- TIMED_WAITING
- TERMINATED
1.1 NEW
顾名思义，这个状态，只存在于线程刚创建，未start之前，例如
MyThread thread = new MyThread();
System.out.println(thread.getState());
此时打印出来的状态就是NEW
1.2 RUNNABLE
这个状态的线程，其正在JVM中执行，但是这个"执行"，不一定是真的在运行， 也有可能是在等待CPU资源。所以，在网上，有人把这个状态区分为READY和RUNNING两个，一个表示的start了，资源一到位随时可以执行，另一个表示真正的执行中，例如
MyThread thread = new MyThread(lock);
thread.start();
System.out.println(thread.getState());
1.3 BLOCKED
这个状态，一般是线程等待获取一个锁，来继续执行下一步的操作，比较经典的就是synchronized关键字，这个关键字修饰的代码块或者方法，均需要获取到对应的锁，在未获取之前，其线程的状态就一直未BLOCKED，如果线程长时间处于这种状态下，我们就是当心看是否出现死锁的问题了。例如
public class MyThread extends Thread {
private byte[] lock = new byte[0];
public MyThread(byte[] lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock){
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("done");
}
}
}
public static void main(String[] args) throws InterruptedException {
byte[] lock = new byte[0];
MyThread thread1 = new MyThread(lock);
thread1.start();
MyThread thread2 = new MyThread(lock);
thread2.start();
Thread.sleep(1000);//等一会再检查状态
System.out.println(thread2.getState());
}
此时我们看到的输出的第二个线程的状态就是BLOCKED
1.4 WAITING
一个线程会进入这个状态，一定是执行了如下的一些代码，例如
- Object.wait()
- Thread.join()
- LockSupport.park()
当一个线程执行了Object.wait()的时候，它一定在等待另一个线程执行Object.notify()或者Object.notifyAll()。或者一个线程thread，其在主线程中被执行了thread.join()的时候，主线程即会等待该线程执行完成。当一个线程执行了LockSupport.park()的时候，其在等待执行LockSupport.unpark(thread)。当该线程处于这种等待的时候，其状态即为WAITING。需要关注的是，这边的等待是没有时间限制的，当发现有这种状态的线程的时候，若其长时间处于这种状态，也需要关注下程序内部有无逻辑异常。例如LockSupport.park()
public class MyThread extends Thread {
private byte[] lock = new byte[0];
public MyThread(byte[] lock) {
this.lock = lock;
}
@Override
public void run() {
LockSupport.park();
}
}
public static void main(String[] args) throws InterruptedException {
byte[] lock = new byte[0];
MyThread thread1 = new MyThread(lock);
thread1.start();
Thread.sleep(100);
System.out.println(thread1.getState());
LockSupport.unpark(thread1);
Thread.sleep(100);
System.out.println(thread1.getState());
}
输出WAITING和TERMINATED
Object.wait()
public class MyThread extends Thread {
private byte[] lock = new byte[0];
public MyThread(byte[] lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock){
try {
lock.wait(); //wait并允许其他线程同步lock
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args)
throws InterruptedException {
byte[] lock = new byte[0];
MyThread thread1 = new MyThread(lock);
thread1.start();
Thread.sleep(100);
System.out.println(thread1.getState()); //这时候线程状态应为WAITING
synchronized (lock){
lock.notify(); //notify通知wait的线程
}
Thread.sleep(100);
System.out.println(thread1.getState());
}
输出WAITING和TERMINATED
Thread.join()
public class MyThread extends Thread {
private byte[] lock = new byte[0];
public MyThread(byte[] lock) {
this.lock = lock;
}
@Override
public void run() {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class MyThread1 extends Thread {
Thread thread;
public MyThread1(Thread thread) {
this.thread = thread;
}
@Override
public void run() {
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Main {
public static void main(String[] args)
throws InterruptedException {
byte[] lock = new byte[0];
MyThread thread = new MyThread(lock);
thread.start();
MyThread1 thread1 = new MyThread1(thread);
thread1.start();
Thread.sleep(100);
System.out.println(thread1.getState());
}
}
输出为WAITING
1.5 TIMED_WAITING
这个状态和WAITING状态的区别就是，这个状态的等待是有一定时效的，即可以理解为WAITING状态等待的时间是永久的，即必须等到某个条件符合才能继续往下走，否则线程不会被唤醒。但是TIMED_WAITING，等待一段时间之后，会唤醒线程去重新获取锁。当执行如下代码的时候，对应的线程会进入到TIMED_WAITING状态
- Thread.sleep(long)
- Object.wait(long)
- Thread.join(long)
- LockSupport.parkNanos()
- LockSupport.parkUntil()
代码示例
Thread.sleep
public class MyThread3 extends Thread {
@Override
public void run() {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Thread thread = new MyThread3();
thread.start();
Thread.sleep(100);
System.out.println(thread.getState());
输出为TIMED_WAITING
Object.wait
public class MyThread4 extends Thread {
private Object lock;
public MyThread4(Object lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock){
try {
lock.wait(1000);//注意，此处1s之后线程醒来，会重新尝试去获取锁，如果拿不到，后面的代码也不执行
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("lock end");
}
}
}
byte[] lock = new byte[0];
MyThread4 thread = new MyThread4(lock);
thread.start();
Thread.sleep(100);
System.out.println(thread.getState());
Thread.sleep(2000);
System.out.println(thread.getState());
输出
TIMED_WAITING
lock end
TERMINATED
其余方法类似
1.6 TERMINATED
这个状态很好理解，即为线程执行结束之后的状态
2. 线程状态图
3. 状态详细说明
3.1 初始状态(NEW)
实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。
3.2 运行状态RUNNABLE
3.2.1 就绪状态(RUNNABLE之READY)
- 就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。
- 调用线程的start()方法，此线程进入就绪状态。
- 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
- 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
- 锁池里的线程拿到对象锁后，进入就绪状态。
3.2.2 运行中状态(RUNNABLE之RUNNING)
线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式。
3.3 阻塞状态(BLOCKED)
阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。
3.4 等待(WAITING)
处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。
3.5 超时等待(TIMED_WAITING)
处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。
3.6 终止状态(TERMINATED)
- 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
- 在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。
4. 等待队列
- 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。
- 与等待队列相关的步骤和图
- 线程1获取对象A的锁，正在使用对象A。
- 线程1调用对象A的wait()方法。
- 线程1释放对象A的锁，并马上进入等待队列。
- 锁池里面的对象争抢对象A的锁。
- 线程5获得对象A的锁，进入synchronized块，使用对象A。
- 线程5调用对象A的notifyAll()方法，唤醒所有线程，所有线程进入同步队列。若线程5调用对象A的notify()方法，则唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入同步队列。
- notifyAll()方法所在synchronized结束，线程5释放对象A的锁。
- 同步队列的线程争抢对象锁，但线程1什么时候能抢到就不知道了。
5. 同步队列状态
- 当前线程想调用对象A的同步方法时，发现对象A的锁被别的线程占有，此时当前线程进入同步队列。简言之，同步队列里面放的都是想争夺对象锁的线程。
- 当一个线程1被另外一个线程2唤醒时，1线程进入同步队列，去争夺对象锁。
- 同步队列是在同步的环境下才有的概念，一个对象对应一个同步队列。
- 线程等待时间到了或被notify/notifyAll唤醒后，会进入同步队列竞争锁，如果获得锁，进入RUNNABLE状态，否则进入BLOCKED状态等待获取锁。
6. 几个方法的比较
- Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。
- Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间。
- thread.join()/thread.join(long millis)，当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程一般情况下进入RUNNABLE状态，也有可能进入BLOCKED状态（因为join是基于wait实现的）。
- obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。
- obj.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。
- LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态，需要通过LockSupport.unpark(Thread thread)唤醒。
7. 疑问
- 等待队列里许许多多的线程都wait()在一个对象上，此时某一线程调用了对象的notify()方法，那唤醒的到底是哪个线程？随机？队列FIFO？or sth else？Java文档就简单的写了句：选择是任意性的（The choice is arbitrary and occurs at the discretion of the implementation）。
扫一扫
1264
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
