Java中六种状态装换

NEW【初始状态】：仅创建了Java线程对象，还没有和操作系统的线程关联起来
RUNNABLE【运行状态、可运行状态、阻塞IO方法的阻塞状态】

线程状态转换.png

情况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

@Slf4j(topic = "ants.RunableWaiting1")
public class RunableWaiting1 {
    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();
        new Thread("t1") {
            @SneakyThrows
            @Override
            public void run() {
                synchronized (o){
                    log.debug("调用wait前");
                    o.wait();
                    log.debug("t1执行后续代码");
                }
            }
        }.start();

        new Thread("t2") {
            @SneakyThrows
            @Override
            public void run() {
                synchronized (o){
                    log.debug("调用wait前");
                    o.wait();
                    log.debug("t2执行后续代码");
                }
            }
        }.start();
        Thread.sleep(1000);
        synchronized (o){
            o.notifyAll();
        }
    }
}

@Slf4j(topic = "ants.RunableWaiting2")
public class RunableWaiting2 {
    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();
        Thread t1 = new Thread("t1") {
            @SneakyThrows
            @Override
            public void run() {
                synchronized (o) {
                    log.debug("调用wait前");
                    o.wait();
                    log.debug("t1执行后续代码");
                }
            }
        };
        t1.start();
        Thread.sleep(10000);
        t1.interrupt();
    }
}

情况3 RUNNABLE <--> WAITING

当前线程调用t.join()方法时，当前线程从RUNNABLE --> WAITING
- 注意当前线程在t线程对象的监视器上等待
t线程运行结束，或调用当前线程的interrupt()时，当前线程从WAITING --> RUNNABLE

情况4 RUNNABLE <--> WAITING

当前线程调用LockSUpport.park()方法会让当前线程从RUNNABLE --> WAITING
d调用LockSUpport.unpark(目标线程)或调用了线程的interrupt()，会让目标线程从WAITING --> RUNNABLE

情况5 RUNNABLE <--> TIME_WAITING

t线程调用synchronized(obj)获得对象锁后

调用obj.wait(long n)方法时，t线程从RUNNABLE --> TIME_WAITING
t线程等待时间超过了n毫秒，或调用object.notify()或obj.notifyAll()时
- 竞争锁成功，t线程从TIME_WAITING --> RUNNABLE
- 竞争锁失败，t线程从TIME_WAITING --> BLOCKED

情况6 RUNNABLE <--> TIME_WAITING

当前线程调用t.join(long n)方法是，当前线程从RUNNABLE --> TIME_WAITING
- 当前线程在t线程对象的监视器上等待
当前线程等待时间超过n毫秒，或t线程运行结束，或调用了当前线程的interrupt()方法是，当前线程从TIME_WAITING --> RUNNABLE

情况7 RUNNABLE <--> TIME_WAITING

当前线程调用Thread.sleep(long n)，当前线程从RUNNABLE --> TIME_WAITING
当前线程等待时间超过了n毫秒，当前线程从TIME_WAITING --> RUNNABLE

情况8 RUNNABLE <--> TIME_WAITING

当前线程调用LockSupport.parkNaos(long naos)或LockSupport.parkUtil(long millis)时，当前线程从RUNNABLE --> TIME_WAITING
调用LockSupport.unpark(目标线程)或调用了线程的interrupt()或是等待时间超时，会让目标线程从TIME_WAITING --> RUNNABLE

情况9 RUNNABLE <--> BLOCKED

t线程调用synchronized(obj)获取了对象锁时，如果竞争失败进入EntryList阻塞，从RUNNABLE --> BLOCKED
持有obj锁线程的同步代码块执行完毕，会唤醒EntryList阻塞的线程，线程重新竞争，如果t线程金正到锁资源从BLOCKED --> RUNNABLE，其他线程会继续是BLOCKED状态