java并发学习21：线程状态转换

1、情况 1 NEW --> RUNNABLE

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

2、情况 2 RUNNABLE <–> WAITING

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

• 调用obj.wait()方法时，t 线程从RUNNABLE --> WAITING

• 调用obj.notify()，obj.notifyAll()，t.interrupt()时

  • 竞争锁成功，t 线程从WAITING --> RUNNABLE
  • 竞争锁失败，t 线程从WAITING --> BLOCKED

  public class Test WaitNotify {
  	final static Object obj = new Object();
      public static void main(String[] args) {
          newThread(() -> {
              synchronized (obj) {
                  log.debug("执行....");
                  try {
                      obj.wait();
                  } catch (InterruptedExceptione) {
                      e.printStackTrace();           
                  }
                  log.debug("其它代码...."); // 断点          
              }       
          },"t1").start();
          
          newThread(() -> {
              synchronized (obj) {
                  log.debug("执行....");
                  try {
                      obj.wait();      
                  } catch (InterruptedExceptione) {
                      e.printStackTrace();            
                  }
                  log.debug("其它代码...."); // 断点         
              }       
          },"t2").start();
          
          sleep(0.5);
          log.debug("唤醒 obj 上其它线程");
          synchronized (obj) {
              obj.notifyAll(); // 唤醒obj上所有等待线程断点      
          }   
      }
  }
  

3、情况 3 RUNNABLE <–> WAITING

• 当前线程调用t.join()方法时，当前线程从RUNNABLE --> WAITING

  • 注意是当前线程在t 线程对象的监视器上等待

• t 线程运行结束，或调用了当前线程的interrupt()时，当前线程从WAITING --> RUNNABLE

4、情况 4 RUNNABLE <–> WAITING

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

5、情况 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
  • 竞争锁失败，t 线程从TIMED_WAITING --> BLOCKED

6、情况 6 RUNNABLE <–> TIMED_WAITING

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

7、情况 7 RUNNABLE <–> TIMED_WAITING

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

8、情况 8 RUNNABLE <–> TIMED_WAITING

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

9、情况 9 RUNNABLE <–> BLOCKED

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

10、情况 10 RUNNABLE <–> TERMINATED

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