4.16多线程--线程状态转换

重新理解线程状态转换

在 java 层面，分为六种状态 NEW RUNNABLE BLOCKED WAITING TIMED_WAITING TERMINATED

image.png

• NEW java 代码创建了线程，还没有关联到操作系统

假设有线程 Thread t
情况1 NEW --> RUNNABLE

• 当调用 t.start() 方法时

情况2 RUNNABLE --> WAITING
t 线程 用 synchronized(obj) 获取了对象锁后

• 调用 obj.wait() 方法时，t 线程 从 RUNNABLE --> WAITING
• 调用 obj.notify(), obj.notifyAll(), t.interrupte() 时
  • 竞争锁成功，t 线程 从 WAITING --> RUNNABLE(IDEA 中 RUNNING)
  • 竞争锁失败，t 线程 从 WAITING --> BLOCKED(IDEA 中 MONITOR)

@Slf4j
public class Demo1 {
    private static Object lock = new Object();
    public static void main(String[] args) {
        new Thread(()->{
            synchronized (lock){
                log.debug("执行");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("继续执行");
            }
        },"t1").start();

        new Thread(()->{
            synchronized (lock){
                log.debug("执行");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("继续执行");
            }
        },"t2").start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("唤醒 lock 上其他线程");
        synchronized (lock){
            lock.notifyAll();
        }
    }
}

情况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(IDEA 中 RUNNING)
  • 竞争锁失败，t 线程 从 TIMED_WAITING --> BLOCKED(IDEA 中 MONITOR)

情况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.parNanos(long nanos) 或 LockSupport.parkUntil(long nillis)时，当前线程 从 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