线程状态转换

线程的六种状态

• new : 线程刚被创建，还没有调用start()，方法
• RUNNABLE 当调用了start(),但是在Java层面RUNNABLE 覆盖了 操作系统层面的 【可运行状态，运行状态，阻塞状态】，由域BIO导致的线程阻塞，在Java这里无法区分，仍然认为时可运行
• BLOCKED，WAITING，TIMED_WAITING 都是JavaAPI层面的堆阻塞状态的细分。
• TERMINATED 当线程代码运行结束

线程状态转换

1.NEW -> RUNNABLE

• 当一个新创建的线程调用start方法的时候，线程进入 RUNNABLE（这里包括就绪、运行、和线程io 阻塞）；

2.RUNNABLE <–> WAITING（现有线程t）

• t 线程调用了 synchronized（lock） 获取的锁对象后，

  • 调用lock.wait() 方法的时候， 线程 t 从 RUNNALE 进入 WAITING
  • 调用lock.notify(), lock.notifyAll(), t.interrupt(),时
    • 竞争锁成功，成功被唤醒 WAITING -> RUNNABLE
    • 竞争锁失败，唤醒失败 WAITING -> BLOCKED

• public class TestWaitNotify {
   final static Object obj = new Object();
   public static void main(String[] args) {
   	 new Thread(() -> {
       synchronized (obj) {
       log.debug("执行....");
       try {
       	obj.wait();
       } catch (InterruptedException e) {
       	e.printStackTrace();
       }
       	log.debug("其它代码...."); // 断点
       }
       },"t1").start();
       new Thread(() -> {
           synchronized (obj) {
           log.debug("执行....");
           try {
           obj.wait();
           } catch (InterruptedException e) {
           e.printStackTrace();
           }
           log.debug("其它代码...."); // 断点
           }
       },"t2").start();
  
       sleep(0.5);
       log.debug("唤醒 obj 上其它线程");
       synchronized (obj) {
       obj.notifyAll(); // 唤醒obj上所有等待线程 断点,然后等待的线程根据设置的相应的条件进行锁的竞争，竞争上的 则进入 runable ， 没有竞争上的 则进入 blokced
       }
   }
  }    
  

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线程等待时间到了，或者是 调用了 obj.notify(),obj.notifyAll(),t.interrupt(),时
  • 竞争成功后，t线程 从 TIMED_WAITING --> RUNNABLE
  • 竞争失败后，t线程 TIMED_WAITING --> BLOCKED

6.RUNNABLE <–> TIMED_WAITING

• 当前线程调用t.join(long n), 方法的时候，当前线程 RUNNABLE --> TIMED_WAITING
  • 注意是当前线程在 t线程对象的监视器上等待
• 当前线程 等待的时间过去了 或者 t 线程运行结束，（因为存在等待时间未结束但是t线程已经运行完毕的情况），或者调用了当前线程的interrupt()，时当前线程从 TIMED_WAITING -> RUNNABLE

7. RUNNABLE <–> TIMED_WAITING

• 当前线程调用了 Thread.sleep(long n),当前线程从 RUNNABLE -> TIMED_WAITING
• 当 sleep 的时间到了，当前线程从 TIMED_WAITING --> RUNNABLE

8. RUNNABLE <–> TIMED_WAITING

• 当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线程从 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