线程生命周期，五大状态转换分析

public enum State {

  // 新建，未调用start方法
  new,
  
  // 包含两种状态：就绪状态、运行状态
  Runnable,
  
  // 阻塞
  Blocked,
  
  /**
   * 等待态
   * 3种情况调用后会导致线程处于这个状态：
   * 1.Object.wait
   * 2.Thread.join
   * 3.LockSupport.park
   * 等待态的线程会等待其他线程执行特定的操作
   * 例如一个线程调用了Object.wait之后进入等待态，另一个线程调用Object.notify或Object.notifyAll可以将其唤醒，被唤醒的线程需要获取对象的锁才能恢复执行
   * 调用Thread.join会等待指定的线程终止
   */
  waiting,
  
  /**
   * 超时等待态
   * 线程等待指定的时间再执行
   * 5种情况调用后会导致线程处于这个状态：
   * 1.Thread.sleep
   * 2.Object.wait 传入等待时长
   * 3.Thread.join 传入等待时长
   * 4.LockSupport.parkNanos
   * 5.LockSupport.parkUntil
   */
  timed_waiting,
  
  // 终止，线程执行完毕
  Terminated;
}

* <li>{@link #new}<br>
* A thread that has not yet started is in this state.
* </li>

* <li>{@link #Runnable}<br>
* A thread executing in the Java virtual machine is in this state.
* </li>

/*
 * <li>{@link #Blocked}<br>
 *     A thread that is blocked waiting for a monitor lock
 *     is in this state.
 *     </li>
 * <li>{@link #waiting}<br>
 *     A thread that is waiting indefinitely for another thread to
 *     perform a particular action is in this state.
 *     </li>
 * <li>{@link #TIMED_waiting}<br>
 *     A thread that is waiting for another thread to perform an action
 *     for up to a specified waiting time is in this state.
 *     </li>

 /**
   * Thread state for a thread blocked waiting for a monitor lock.
   * A thread in the blocked state is waiting for a monitor lock
   * to enter a synchronized block/method or
   * reenter a synchronized block/method after calling
   * {@link Object#wait() Object.wait}.
   */
  Blocked

/**
* Thread state for a waiting thread.
* A thread is in the waiting state due to calling one of the
* following methods:
* <ul>
*   <li>{@link Object#wait() Object.wait} with no timeout</li>
*   <li>{@link #join() Thread.join} with no timeout</li>
*   <li>{@link LockSupport#park() LockSupport.park}</li>
* </ul>
*
* <p>A thread in the waiting state is waiting for another thread to
* perform a particular action.
*
* For example, a thread that has called <tt>Object.wait()</tt>
* on an object is waiting for another thread to call
* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
* that object. A thread that has called <tt>Thread.join()</tt>
* is waiting for a specified thread to terminate.
*/
waiting

public class Thread{
    // 线程的启动
    public void start(); 
    // 线程体
    public void run(); 
    // 已废弃
    public void stop(); 
    // 已废弃
    public void resume(); 
    // 已废弃
    public void suspend(); 
    // 在指定的毫秒数内让当前正在执行的线程休眠
    public static void sleep(long millis); 
    // 同上，增加了纳秒参数
    public static void sleep(long millis, int nanos); 
    // 测试线程是否处于活动状态
    public boolean isAlive(); 
    // 中断线程
    public void interrupt(); 
    // 测试线程是否已经中断
    public boolean isInterrupted(); 
    // 测试当前线程是否已经中断
    public static boolean interrupted(); 
    // 等待该线程终止
    public void join() throws InterruptedException; 
    // 等待该线程终止的时间最长为 millis 毫秒
    public void join(long millis) throws InterruptedException; 
    // 等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒
    public void join(long millis, int nanos) throws InterruptedException; 
}