1、线程的6种状态

  • Thread类中有个线程状态的枚举类型

    1. public class Thread implements Runnable {
    2.   public enum State {
    3.       NEW,
    5.       RUNNABLE,
    7.       BLOCKED,
    9.       WAITING,
    11.       TIMED_WAITING,
    13.       TERMINATED;
    14.   }
    15. }

  • 线程状态图

4-1、线程状态 - 图1

2、NEW（新建状态）

  • 线程对象被创建后，还没有调用start方法，就进入了新建状态

    1.       Thread thread = new Thread();
    2.       System.out.println(thread.getState());

    3、Runnable（可运行状态）

  • 这个状态的线程，其正在JVM中执行，但是这个”执行”，不一定是真的在运行， 也有可能是在等待CPU资源。所以，在网上，有人把这个状态区分为READY和RUNNING两个，一个表示的start了，资源一到位随时可以执行，另一个表示真正的执行中

    1.       Thread thread = new Thread();
    2.       thread.start();
    3.       System.out.println(thread.getState());

4、Blocked（阻塞状态）

  • 这个状态，一般是线程等待获取一个锁，来继续执行下一步的操作，比较经典的就是synchronized关键字，这个关键字修饰的代码块或者方法，均需要获取到对应的锁，在未获取之前，其线程的状态就一直未BLOCKED，如果线程长时间处于这种状态下，我们就是当心看是否出现死锁的问题了
  • 下例输出结果

    Thread-0: start TIMED_WAITING BLOCKED Thread-0: end Thread-1: start Thread-1: end

  1. public class Main {
  2.     public static void main(String[] args) {
  4.         Object obj = new Object();
  6.         MyThread thread1 = new MyThread(obj);
  7.         thread1.start();
  8.         MyThread thread2 = new MyThread(obj);
  9.         thread2.start();
  11.         try {
  12.             Thread.sleep(1000);
  13.         } catch (InterruptedException e) {
  14.             e.printStackTrace();
  15.         }
  17.         // TIMED_WAITING
  18.         System.out.println(thread1.getState());
  19.         // BLOCKED
  20.         System.out.println(thread2.getState());
  21.     }
  23.     public static class MyThread extends Thread {
  24.         private Object obj;
  26.         public MyThread(Object obj) {
  27.             this.obj = obj;
  28.         }
  30.         @Override
  31.         public void run() {
  32.             synchronized (obj){
  33.                 System.out.println(Thread.currentThread().getName()+": start");
  34.                 try {
  35.                     Thread.sleep(10000);
  36.                 } catch (InterruptedException e) {
  37.                     e.printStackTrace();
  38.                 }
  39.                 System.out.println(Thread.currentThread().getName()+": end");
  40.             }
  41.         }
  42.     }
  43. }

5、WAITING（无限等待）

  • WAITING状态的线程不再活动，不会浪费CPU资源，也不会去竞争锁；此状态下会等待别的线程执行notify通知，重新进入调度队列中

  • 一个线程进入WAITING无限等待状态，一定是执行了如下的代码

    • Object.wait()

      当一个线程执行了Object.wait()的时候，它一定在等待另一个线程执行Object.notify()或者Object.notifyAll()。

    • Thread.join()

      一个线程thread，其在主线程中被执行了thread.join()的时候，主线程即会等待该线程执行完成。

    • LockSupport.park()

      当一个线程执行了LockSupport.park()的时候，其在等待执行LockSupport.unpark(thread)。

  • 需要关注的是，这边的等待是没有时间限制的，当发现有这种状态的线程的时候，若其长时间处于这种状态，也需要关注下程序内部有无逻辑异常

    Object.wait()

  • 代码执行效果

    Thread-0: start 0 1 wait WAITING notify 2 3 4 Thread-0: end

  1. public class Main {
  2.     public static void main(String[] args) throws InterruptedException {
  4.         Object obj = new Object();
  5.         MyThread thread1 = new MyThread(obj);
  6.         thread1.start();
  8.         Thread.sleep(4000);
  9.         // WAITING
  10.         System.out.println(thread1.getState());
  12.         synchronized (obj){
  13.             obj.notify();
  14.             System.out.println("notify");
  15.         }
  16.     }
  18.     public static class MyThread extends Thread {
  19.         private Object obj;
  21.         public MyThread(Object obj) {
  22.             this.obj = obj;
  23.         }
  25.         @Override
  26.         public void run() {
  27.             synchronized (obj){
  28.                 System.out.println(Thread.currentThread().getName()+": start");
  29.                 for (int i = 0; i < 5; i++) {
  31.                     try {
  32.                         if (i == 2){
  33.                             System.out.println("wait");
  34.                             obj.wait();
  35.                         }
  37.                         Thread.sleep(1000);
  38.                         System.out.println(i);
  39.                     } catch (InterruptedException e) {
  40.                         e.printStackTrace();
  41.                     }
  42.                 }
  43.                 System.out.println(Thread.currentThread().getName()+": end");
  44.             }
  45.         }
  46.     }
  47. }

thread.join()

  • 执行结果

    thread1 start thread2 start thread1.join()后 , thread2 等待 thread1 执行完毕

thread1 end

thread1 执行完毕，thread2继续执行

thread2 end

  1. public class Main {
  2.     public static void main(String[] args) throws InterruptedException {
  4.         Thread1 thread1 = new Thread1();
  5.         thread1.setName("thread1");
  6.         thread1.start();
  8.         Thread2 thread2 = new Thread2(thread1);
  9.         thread2.setName("thread2");
  10.         thread2.start();
  11.     }
  13.     public static class Thread1 extends Thread {
  15.         public Thread1() {
  17.         }
  19.         @Override
  20.         public void run() {
  21.             System.out.println(Thread.currentThread().getName()+" start");
  23.             try {
  24.                 Thread.sleep(3000);
  25.             } catch (InterruptedException e) {
  26.                 e.printStackTrace();
  27.             }
  28.             System.out.println(Thread.currentThread().getName()+" end");
  29.         }
  30.     }
  32.     public static class Thread2 extends Thread {
  34.         private Thread thread1;
  36.         public Thread2(Thread thread1) {
  37.             this.thread1 = thread1;
  38.         }
  40.         @Override
  41.         public void run() {
  43.             System.out.println(Thread.currentThread().getName()+" start");
  44.             try {
  45.                 System.out.println("thread1.join()后 , thread2 等待 thread1 执行完毕");
  46.                 // 等待thread1执行完毕后，当前线程(就是thread2)才会执行后续
  47.                 thread1.join();
  48.                 System.out.println("thread1 执行完毕，thread2继续执行");
  50.             } catch (InterruptedException e) {
  51.                 e.printStackTrace();
  52.             }
  53.             System.out.println(Thread.currentThread().getName()+" end");
  54.         }
  55.     }
  56. }

LockSupport.park()

  • 代码执行结果

    Thread-0 start

WAITING

Thread-0 end

TERMINATED

  1. public class Main {
  2.     public static void main(String[] args) throws InterruptedException {
  4.         MyThread thread1 = new MyThread();
  5.         thread1.start();
  7.         Thread.sleep(100);
  9.         // WAITING
  10.         System.out.println(thread1.getState());
  12.         // 唤醒线程
  13.         LockSupport.unpark(thread1);
  14.         Thread.sleep(100);
  16.         // TERMINATED
  17.         System.out.println(thread1.getState());
  18.     }
  20.     public static class MyThread extends Thread {
  23.         @Override
  24.         public void run() {
  26.             System.out.println(Thread.currentThread().getName()+" start");
  27.             // 阻塞线程
  28.             LockSupport.park();
  29.             System.out.println(Thread.currentThread().getName()+" end");
  30.         }
  31.     }
  32. }

6、TIMED_WAITING（计时等待）

  • 这个状态和WAITING状态的区别就是，这个状态的等待是有一定时效的，即可以理解为WAITING状态等待的时间是永久的，即必须等到某个条件符合才能继续往下走，否则线程不会被唤醒。但是TIMED_WAITING，等待一段时间之后，会唤醒线程去重新获取锁。当执行如下代码的时候，对应的线程会进入到TIMED_WAITING状态

  • 以下这几个方法都会导致线程进入TIMED_WAITING

    • Thread.sleep(long)
    • Object.wait(long)
    • Thread.join(long)
    • LockSupport.parkNanos()
    • LockSupport.parkUntil()

      Thread.sleep(long)

  • 下面代码执行结果

    Thread-0: start TIMED_WAITING

Thread-0: end

TERMINATED

  1.         Thread thread = new Thread(new Runnable() {
  2.             @Override
  3.             public void run() {
  4.                 System.out.println(Thread.currentThread().getName()+": start");
  6.                 try {
  7.                     Thread.sleep(3000);
  8.                 } catch (InterruptedException e) {
  9.                     e.printStackTrace();
  10.                 }
  12.                 System.out.println(Thread.currentThread().getName()+": end");
  13.             }
  14.         });
  15.         thread.start();
  17.         try {
  18.             Thread.sleep(1000);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  23.         // TIMED_WAITING
  24.         System.out.println(thread.getState());
  26.         try {
  27.             Thread.sleep(3000);
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         }
  32.         // TERMINATED
  33.         System.out.println(thread.getState());

obj.wait(long)

  • 代码执行结果

    Thread-0: start

0

1

wait sart

TIMED_WAITING

wait end

2

3

4

Thread-0: end

  1. public class Main {
  2.     public static void main(String[] args) throws InterruptedException {
  4.         Object obj = new Object();
  5.         MyThread thread1 = new MyThread(obj);
  6.         thread1.start();
  8.         Thread.sleep(2000);
  9.         // WAITING
  10.         System.out.println(thread1.getState());
  12.     }
  14.     public static class MyThread extends Thread {
  15.         private Object obj;
  17.         public MyThread(Object obj) {
  18.             this.obj = obj;
  19.         }
  21.         @Override
  22.         public void run() {
  23.             synchronized (obj){
  24.                 System.out.println(Thread.currentThread().getName()+": start");
  25.                 for (int i = 0; i < 5; i++) {
  27.                     try {
  28.                         if (i == 2){
  29.                             System.out.println("wait sart");
  30.                             obj.wait(3000);
  31.                             System.out.println("wait end");
  32.                         }
  33.                         System.out.println(i);
  34.                     } catch (InterruptedException e) {
  35.                         e.printStackTrace();
  36.                     }
  37.                 }
  38.                 System.out.println(Thread.currentThread().getName()+": end");
  39.             }
  40.         }
  41.     }
  42. }

7、TERMINATED（终止）

  • 线程执行结束之后的状态