状态简介

thread源码中可以找到枚举状态：

线程状态 导致状态发生条件
New (新建) 线程刚被创建，但是并未启动，还没调用 start 方法，只有线程对象，没有线程特征
Runnable (可运行) 线程可以在 java 虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器，调用了 t.start() 方法：就绪（经典叫法）
Blocked (锁阻塞) 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入 Blocked 状态；当该线程持有锁时，该线程将变成 Runnable 状态
Waiting (无限等待) 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入 Waiting 状态，进入这个状态后不能自动唤醒，必须等待另一个线程调用 notify 或者 notifyAll 方法才能唤醒
Timed Waiting (计时等待) 有几个方法有超时参数，调用将进入 Timed Waiting 状态，这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有 Thread.sleep 、Object.wait
Teminated (被终止) run 方法正常退出而死亡，或者因为没有捕获的异常终止了 run 方法而死亡

代码实现

新建-New

  1.   public void newState(){
  2.         ThreadDemo1 t = new ThreadDemo1();
  3.         System.out.println(t.getState());//NEW
  4.     }

可运行-Runnable

  1. public void runnableState(){
  2.         Thread t = new Thread(()->{
  3.             for (int i=0 ;i<1000;i++) {
  4.             }
  5.         });
  6.         t.start();
  7.         System.out.println(t.getState());//RUNNABLE
  8.     }

阻塞-Blocked

  1. public void blockedState() {
  2.     Object o = new Object();
  3.     Thread t1 =
  4.         new Thread(
  5.             () -> {
  6.               synchronized (o) {
  7.                   try {
  8.                       Thread.sleep(1000*10);
  9.                   } catch (InterruptedException e) {
  10.                       e.printStackTrace();
  11.                   }
  12.               }
  13.             });
  14.     Thread t2 =
  15.         new Thread(
  16.             () -> {
  17.                 synchronized (o) {
  18.                     System.out.println("t2");
  19.                 }
  20.             });
  21.     t1.start();
  22.       try {
  23.           Thread.sleep(100);
  24.       } catch (InterruptedException e) {
  25.           e.printStackTrace();
  26.       }
  27.     t2.start();
  29.     System.out.println(t1.getState()); // TIMED_WAITING
  30.     System.out.println(t2.getState()); // BLOCKED
  31.   }

无限等待-Waiting

  1.  Thread t1 = new Thread(()->{
  2.         while(true) { // runnable
  4.         }
  5.  });
  7. Thread t2 = new Thread(()->{
  8.             try {
  9.                 t1.join(); // waiting
  10.             } catch (InterruptedException e) {
  11.                 e.printStackTrace();
  12.             }
  13.         });

计时等待-Timed_Waiting

  1.  Thread t4 = new Thread("t4") {
  2.             @Override
  3.             public void run() {
  4.                 synchronized (TestState.class) {
  5.                     try {
  6.                         Thread.sleep(1000000); // timed_waiting
  7.                     } catch (InterruptedException e) {
  8.                         e.printStackTrace();
  9.                     }
  10.                 }
  11.             }
  12.         };

被终止-Teminated

  1.   Thread t3 = new Thread("t3") {
  2.             @Override
  3.             public void run() {
  4.                 log.debug("running...");
  5.             }
  6.         };