[Java多线程编程之二] 当初叫人家小甜甜，现在叫我牛夫人 —

一、线程生命周期与状态

  一个线程从创建、运行到终止称为一个生命周期，线程在其生命周期中要经历创建、就绪、运行、阻塞、等待、终止多种状态，这多种状态的转换图如图所示：

  当一个线程对象被创建时，状态为New；当线程启动时，进入Runnable状态；当线程运行由于资源或锁被占用时，进入Blocked状态；当线程休眠时，进入等待状态；当线程执行完毕或发生中断异常是时，线程运行结束，进入Terminated状态。
  JDK的Thread类中定义了线程状态的内部枚举类State，如下所示：

    public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

1、New

  当一个Thread类或其子类使用new关键字声明一个对象实例时，JVM为对象分配堆内存，此时线程处于新建状态，但是线程还没有被运行，即没有被激活。

2、Runnable

  处于新建状态的线程通过调用start方法启动后，线程进入就绪状态，这时的线程已经拥有了运行所需的所有条件，将进入线程队列排队等待CPU调度。由于还没有获得CPU时间片，所以启动后不会被立即执行；当获得CPU时间片后，线程由就绪状态转换为运行状态，处于运行状态的线程将执行run方法中定义的操作。
  当然，State枚举类中没有对这两个状态加以区分，我们也很难肉眼判断线程是就绪还是运行中，这依赖于操作系统对CPU的时间分片调度。

3、Blocked

  线程运行过程中可能由于某些原因让出正在使用的CPU资源，进入阻塞（Blocked）状态，这些情况包括：

• 某些共享资源（如打印机或文件资源等）被占用；
• 等待IO操作；
• 调用了suspend等方法；
• 尝试获得锁，而该锁正在被其他线程持有。
    为了提高CPU的使用率，当一个线程被阻塞时，另一个线程就获得了运行的机会。当阻塞的原因被消除后，线程将进入就绪状态等待继续执行。
  
  

4、Waiting

  当线程遇到下面的情况时会进入等待（Waiting）状态，包括：

• 调用wait方法，等待其他线程通知；
• 调用park方法，等待其他线程调用unpark()释放许可证。
  
  

5、Timed Waiting

  当线程遇到下面情况时会进入超时等待（Timed Waiting）状态，包括：

• 调用sleep方法；
• 调用带超时时间的park方法。
  
  

6、Terminated

  当线程遇到下面的情况时会进入终止（Terminated）状态，包括：

• 线程的run方法执行结束；
• 线程通过某些方法（例如Destory()）被提前终止；
• 在run方法的执行期间发生了未捕获的异常
• 程序的终止操作（如调用System.exit）
  
  

二、实例演示

  常见的线程转态切换有以下几种：

1、新建 -> 运行 -> 结束

  当线程被创建时，进入新建状态；
  当线程启动时，进入运行状态；
  当run方法体执行结束时，进入终止状态。

代码示例如下：

public class Demo2 {
    public static void main(String[] args) throws Exception {
        // 第一种状态切换: 新建 -> 运行 -> 终止
        System.out.println("####### 第一种状态切换: 新建 -> 运行 -> 终止 #######");
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread1当前状态: " + Thread.currentThread().getState().toString());
                System.out.println("thread1执行了");
            }
        });
        System.out.println("没调用start方法，thread1当前状态: " + thread1.getState().toString());
        thread1.start();
        Thread.sleep(2000L);   // 主线程休眠两秒，让thread1执行结束后，再看其状态
        System.out.println("等待两秒，再看thread1当前状态: " + thread1.getState().toString());
        System.out.println();
        // thread1.start();   // 注意: 线程终止后，再调用start方法，会抛出IllegalThreadStateException异常
   }
}

运行结果：

####### 第一种状态切换: 新建 -> 运行 -> 终止 #######
没调用start方法，thread1当前状态: NEW
thread1当前状态: RUNNABLE
thread1执行了
等待两秒，再看thread1当前状态: TERMINATED

[注意] 当线程结束时，再次启动线程会抛出IllegalThreadStateException异常

2、新建 -> 运行 -> 等待（超时）-> 运行 -> 结束

  当线程被创建时，进入新建状态
  当线程被启动时，进入运行状态
  当调用sleep/park（带超时时间）方法是，进入等待（超时）状态
  当线程休眠结束或者拿到许可证时，重新进入运行状态
  当run方法体执行结束时，进入终止状态。

代码示例如下：

public class Demo2 {
    public static void main(String[] args) throws Exception {
        // 第二种状态切换: 新建 -> 运行 -> 等待(超时) -> 运行 -> 终止 (通过线程休眠切换到等待状态)
        System.out.println("####### 第二种状态切换: 新建 -> 运行 -> 等待(超时) -> 运行 -> 终止  #######");
        Thread thread2 = new Thread(new Runnable() {            
            @Override
            public void run() {
                try {    // 将线程移动到等待状态，1500ms后自动唤醒
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread2当前状态: " + Thread.currentThread().getState().toString());
                System.out.println("thread2 执行了");
            }
        });
        System.out.println("没调用start方法，thread2当前状态: " + thread2.getState().toString());
        thread2.start();
        System.out.println("调用start方法，thread2当前状态: " + thread2.getState().toString());
        Thread.sleep(200L);   // 等待200ms，再看状态
        System.out.println("等待200毫秒，再看thread2当前状态: " + thread2.getState().toString());
        Thread.sleep(3000L);  // 再等待3秒，让thread2执行完毕，再看状态
        System.out.println("等待3秒，再看thread2当前状态: " + thread2.getState().toString());
        System.out.println();
    }
}

运行结果：

####### 第二种状态切换: 新建 -> 运行 -> 等待 -> 运行 -> 终止  #######
没调用start方法，thread2当前状态: NEW
调用start方法，thread2当前状态: RUNNABLE
等待200毫秒，再看thread2当前状态: TIMED_WAITING
thread2当前状态: RUNNABLE
thread2 执行了
等待3秒，再看thread2当前状态: TERMINATED

3、新建 -> 运行 -> 等待（通知/许可）-> 运行 -> 结束

  当线程被创建时，进入新建状态
  当线程被启动时，进入运行状态
  当调用wait/park方法是，进入等待（通知/许可）状态
  当线程收到通知或者拿到许可证时，重新进入运行状态
  当run方法体执行结束时，进入终止状态。

代码如下：

public class Demo2 {
    public static void main(String[] args) throws Exception {
        // 第四种状态切换: 新建 -> 运行 -> 等待(通知) -> 运行 -> 终止
        System.out.println("####### 第四种状态: 新建 -> 运行 -> 等待(通知) -> 运行 -> 终止  #######");
        Thread thread4 = new Thread(new Runnable() {            
            @Override
            public void run() {
                try {
                    synchronized (Demo2.class) {
                        Demo2.class.wait();
                    }
                    System.out.println("thread4收到通知，当前状态: " + Thread.currentThread().getState().toString());
                } catch (InterruptedException e) {                  
                    e.printStackTrace();
                }
                
            }
        });
        System.out.println("没调用start方法，thread4当前状态: " + thread4.getState().toString());
        thread4.start();
        System.out.println("调用start方法，thread4当前状态: " + thread4.getState().toString());
        Thread.sleep(200L);  // 等待200ms，再看状态
        System.out.println("等待200毫秒，再看thread4当前状态: " + thread4.getState().toString());
        synchronized (Demo2.class) {
            Demo2.class.notifyAll();
        }
        Thread.sleep(3000L);  // 再等待3秒，让thread3执行完毕，再看状态
        System.out.println("等待3秒，让thread4执行结束，再看thread4当前状态: " + thread4.getState().toString());
        System.out.println();   
    }
}

运行结果：

####### 第四种状态: 新建 -> 运行 -> 等待 -> 运行 -> 终止  #######
没调用start方法，thread4当前状态: NEW
调用start方法，thread4当前状态: RUNNABLE
等待200毫秒，再看thread4当前状态: WAITING
thread4收到通知，当前状态: RUNNABLE
等待3秒，让thread4执行结束，再看thread4当前状态: TERMINATED

4、新建 -> 运行 -> 阻塞 -> 运行 -> 结束

  当线程被创建时，进入新建状态
  当线程被启动时，进入运行状态
  当线程等待获取锁或其他资源时，进入阻塞状态
  当线程拿到了锁或阻塞的资源时，重新进入运行状态
  当run方法体执行结束时，进入终止状态。

代码如下：

public class Demo2 {
    public static void main(String[] args) throws Exception {
        // 第三种状态切换: 新建 -> 运行 -> 阻塞 -> 运行 -> 终止 (通过线程抢锁切换到阻塞状态)
        System.out.println("####### 第三种状态切换: 新建 -> 运行 -> 阻塞 -> 运行 -> 终止  #######");
        Thread thread3 = new Thread(new Runnable() {            
            @Override
            public void run() {
                synchronized (Demo2.class) {
                    System.out.println("thread3当前状态: " + Thread.currentThread().getState().toString());
                    System.out.println("thread3 执行了");                  
                }
            }
        });
        synchronized (Demo2.class) {
            System.out.println("没调用start方法，thread3当前状态: " + thread3.getState().toString());
            thread3.start();
            System.out.println("调用start方法，thread3当前状态: " + thread3.getState().toString());
            Thread.sleep(200L);  // 等待200ms，再看状态
            System.out.println("等待200毫秒，再看thread3当前状态: " + thread3.getState().toString());
        }
        Thread.sleep(3000L);  // 再等待3秒，让thread3执行完毕，再看状态
        System.out.println("等待3秒，让thread3抢到锁，再看thread3当前状态: " + thread3.getState().toString());
        System.out.println();
    }
}

结果如下：

####### 第三种状态切换: 新建 -> 运行 -> 阻塞 -> 运行 -> 终止  #######
没调用start方法，thread3当前状态: NEW
调用start方法，thread3当前状态: RUNNABLE
等待200毫秒，再看thread3当前状态: BLOCKED
thread3当前状态: RUNNABLE
thread3 执行了
等待3秒，让thread3抢到锁，再看thread3当前状态: TERMINATED