Java 线程状态demo

Java 中的Thread共有6种状态

• NEW
• RUNNABLE
• BLOCKED
• WAITING
• TERMINATED
• TIMED_WAITING

下面模拟 NEW，RUNNABLE， TERMINATED三种状态 Thread 被new出来以后，就处于NEW状态 执行start() 后，处于RUNNABLE状态 执行结束后，处于TERMINATED状态

public class Thread1 {
  public static void main(String [] args) throws Exception {
    Thread t1 = new Thread(new Runnable(){
      @Override
      public void run() {
        System.out.println("th 当前状态" + Thread.currentThread().getState().toString());
        System.out.println("th 执行结束！");
      }
    });

    System.out.println("没有执行start方法，线程当前状态：" + t1.getState().toString());
    t1.start();
    System.out.println("执行start方法，线程当前状态：" + t1.getState().toString());
    Thread.sleep(2000L);
    System.out.println("执行sleep，线程当前状态：" + t1.getState().toString());
  }
}

>> 
没有执行start方法，线程当前状态：NEW
执行start方法，线程当前状态：RUNNABLE
th 当前状态RUNNABLE
th 执行结束！
执行sleep，线程当前状态：TERMINATED

下面模拟出TIMED_WAITING状态。当线程中有一个sleep的时候。就会触发该状态。 此外Object.wait(),Thread.join(),LockSupport.parkNanos(),LockSupport.parkUtil()方法都会触发TIMED_WAITING状态。

public class Thread2 {
  public static void main(String [] args) throws Exception {

    Thread t2 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          Thread.sleep(2000L);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println("t2 执行结束！");
      }
    });

    // System.out.println("没有执行start方法，线程当前状态：" + t2.getState().toString());
    // t2.start();
    // Thread.sleep(200L);
    // System.out.println("执行start方法，线程当前状态：" + t2.getState().toString());
    // System.out.println("执行sleep，线程当前状态：" + t2.getState().toString());

    >> 没有执行start方法，线程当前状态：NEW
    执行start方法，线程当前状态：TIMED_WAITING
    执行sleep，线程当前状态：TIMED_WAITING
    t2 执行结束！
    

下面模拟WAITING状态。 31 wait() 时，就处于WAITING状态，等32 notify之后，才继续执行，知道结束。

public class Thread1 {
  public static void main(String [] args) throws Exception {
    
    Thread t31 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("t31 开始执行！");
        try {
          synchronized (LOCK) {
            LOCK.wait();
          }
        } catch(InterruptedException e) {
          e.printStackTrace();
        }
        
        System.out.println("t31 执行结束！");
      }
    });
    Thread t32 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("t32 开始执行");
        try {
          synchronized (LOCK) {
            Thread.sleep(2000L);
            LOCK.notify();
          }
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println("t32 执行结束");
      }
    });
    
    t31.start();
    Thread.sleep(20L);
    System.out.println("执行start方法，t31 线程当前状态：" + t31.getState().toString());
    t32.start();
    Thread.sleep(200L);
    System.out.println("执行start方法，t32 线程当前状态：" + t32.getState().toString());
  }
}
  

下面模拟如何出现BLOCKED 线程41和线程42被创建了，同时start()，41先获得锁，此时42处于BLOCKED状态，等待41执行完毕后，42才获得锁，然后开始执行，直到结束。

public class Thread {
    private static final Object LOCK = new Object();
    Thread t41 = new Thread(new Runnable() {
      @Override
      public void run() {
        synchronized(LOCK) {
          try {
            Thread.sleep(2000L);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println("t42 执行结束！");
        }
      }
    });

    Thread t42 = new Thread(new Runnable() {
      @Override
      public void run() {
        synchronized(LOCK) {
          try {
            Thread.sleep(2000L);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          System.out.println("t42 执行结束！");
        }
      }
    });

    t41.start();
    t42.start();
    System.out.println("执行start方法，t41 线程当前状态：" + t41.getState().toString());
    System.out.println("执行start方法，t42 线程当前状态：" + t42.getState().toString());
  }
}

    > 执行start方法，t41 线程当前状态：RUNNABLE
    执行start方法，t42 线程当前状态：BLOCKED
    t42 执行结束！
    t42 执行结束！