JAVA并发编程（五）-理解线程状态转换

**

本章的小节分层结构将按照上图中的各个连线进行编写。

**

😈一、NEW->RUNNABLE

  当调用了t.start()方法时，由NEW->RUNNABLE

👿二、RUNNABLE->WAITING(wait-notify)

  当线程用synchronized(obj)获取了对象锁后

（1）调用obj.wait()方法时，t线程从RUNNABLE->WAITING
注意这里线程进入了WAITING状态的同时，释放了锁的拥有权
（2）调用obj.notify()，obj.notifyAll（），t.interrupt()时：
  竞争锁成功,t线程从WAITING->RUNNABLE
  竞争锁失败，t线程从WAITING->BLOCKED

演示代码：

@Slf4j(topic = "TestWaitNotify")
public class TestWaitNotify {

    final static Object object = new Object();

    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            synchronized (object) {
                log.debug("执行代码");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                log.debug("其他代码");
            }
        },"t1").start();

        new Thread(() -> {
            synchronized (object) {
                log.debug("执行代码");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                log.debug("其他代码");
            }
        },"t2").start();


        //睡眠两秒
        TimeUnit.SECONDS.sleep(2);

        synchronized (object){

            log.debug("唤醒其中一个线程");
            object.notifyAll();
        }

    }
}

这里我们可以看到当main线程notifyAll（）并且释放掉锁以后，t2线程竞争锁成功，从WAITING->RUNNING，t1线程竞争锁失败，从WAITING->BLOCKED(这里IDEA显示的会是MONITOR)。

👹三、RUNNABLE<–>WAITING（join-interrupt）

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

👺四、RUNNABLE<–>WAITING（park-unpark）

（1）当前线程调用LockSupport.park()方法会让当前线程从RUNNABLE->WAITING
(2)调用LockSupport.unpark（目标线程）或调用了县城额Interrupt（），会让目标线程从WAITING->RUNNABLE

🤡五、RUNNABLE<-- >TIMED_WAITING（wait-notify）

t线程用synchronized（obj）获取了对象锁后
（1）调用obj.wait(long n)方法时，t线程从RUNNABLE->TIMED_WAITING
（2）t线程等待时间超过了n毫秒，或调用obj.notify(),obj.notifyAll(),t.interrupt()时
-竞争锁成功，t线程从TIMED_WAITING->RUNNABLE
-竞争锁失败，t线程从TIMED_WAITING->BLOCKED

👻六、RUNNABLE<–>TIMED_WAITING（join）

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

💀七、RUNNABLE<–>TIMED_WAITING（sleep）

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

☠️八、RUNNABLE<–>TIMED_WAITING（park和unpark）

(1)当前线程调用LockSupport.parkNanos(long nanos)或LockSupport.parkUntil(long millis)时，当前线程从RUNNABLE->TIMED_WAITING
(2)调用LockSupport.unpark(目标线程)或调用了线程的interrupt（），或是等待超时，会让目标线程从TIMED_WAITING->RUNNABLE。

👽九、RUNNABLE<–>BLOCKED

（1）t线程用synchornized（obj）获取了对象锁时如果竞争失败，从RUNNABLE->BLOCKED
（2）持obj锁线程的同步代码块执行完毕，会唤醒该对象上所有的BLOCKED的线程重新竞争，如果其中t线程竞争成功，从BLOCKED->RUNNABLE，其它失败的线程仍然为BLOCKED。

🤖十、RUNNABLE<–>TERMINATED

当前线程所有代码运行完毕，进入TERMINATED。