生命周期图

image.png

线程的 7 种状态

JDK 中用 Thread.State 枚举类定义了线程的几种状态，想要实现多线程，必须在主线程中创建新的线程对象。

Java 语言使用 Thread 及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的 5 种状态。

NEW
1）新建
当一个Thread类或其子类的对象被声明并创建时，此时线程尚未启动，新生的线程对象处于新建状态。

RUNNABLE
2）就绪 ready
处于新建状态的线程被 start() 后，将进入线程队列等待 CPU 时间片，此时它已具备了运行的条件，只是没分配到 CPU 资源。

3）运行 running
当就绪的线程被调度并获得 CPU 资源时，便进入运行状态，run() 方法定义了线程的操作和功能。

BLOCKED
4）阻塞
进入一个同步块/方法前，处于阻塞状态的线程正在等待锁，或者在调用 Object.wait 后重新进入一个同步块/方法。阻塞时，线程让出 CPU 并临时终止自己的执行。

WAITING
5）等待中
一个等待中的线程的状态。一个线程由于调用了以下方法之一而处于等待状态。

  • 没有设置超时时间的 Object.wait；
  • 没有设置超时时间的 Thread.join；
  • LockSupport.park

一个处于等待状态的线程正在等待另一个线程执行一个特定的动作。例如，一个在对象上调用了 Object.wait() 的线程正在等待另一个线程对该对象调用 Object.notify() 或 Object.notifyAll() 。一个调用了 Thread.join() 的线程正在等待一个指定的线程终止。

TIMED_WAITING**
6）定时等待
一个具有指定等待时间的等待线程的线程状态。一个线程由于以指定的正数等待时间调用了以下方法之一而处于定时的等待状态。

  • Thread.sleep
  • Object.wait with timeout
  • Thread.join with timeout
  • LockSupport.parkNanos
  • LockSupport.parkUntil

TERMINATED
7）终止
线程完成了它的全部工作或线程被提前强制性地终止或出现异常导致结束

Thread.State 源码

  1. public enum State {
  2.     /**
  3.          * Thread state for a thread which has not yet started.
  4.          */
  5.     NEW,
  7.     /**
  8.          * Thread state for a runnable thread.  A thread in the runnable
  9.          * state is executing in the Java virtual machine but it may
  10.          * be waiting for other resources from the operating system
  11.          * such as processor.
  12.          */
  13.     RUNNABLE,
  15.     /**
  16.          * Thread state for a thread blocked waiting for a monitor lock.
  17.          * A thread in the blocked state is waiting for a monitor lock
  18.          * to enter a synchronized block/method or
  19.          * reenter a synchronized block/method after calling
  20.          * {@link Object#wait() Object.wait}.
  21.          */
  22.     BLOCKED,
  24.     /**
  25.          * Thread state for a waiting thread.
  26.          * A thread is in the waiting state due to calling one of the
  27.          * following methods:
  28.          * <ul>
  29.          *   <li>{@link Object#wait() Object.wait} with no timeout</li>
  30.          *   <li>{@link #join() Thread.join} with no timeout</li>
  31.          *   <li>{@link LockSupport#park() LockSupport.park}</li>
  32.          * </ul>
  33.          *
  34.          * <p>A thread in the waiting state is waiting for another thread to
  35.          * perform a particular action.
  36.          *
  37.          * For example, a thread that has called {@code Object.wait()}
  38.          * on an object is waiting for another thread to call
  39.          * {@code Object.notify()} or {@code Object.notifyAll()} on
  40.          * that object. A thread that has called {@code Thread.join()}
  41.          * is waiting for a specified thread to terminate.
  42.          */
  43.     WAITING,
  45.     /**
  46.          * Thread state for a waiting thread with a specified waiting time.
  47.          * A thread is in the timed waiting state due to calling one of
  48.          * the following methods with a specified positive waiting time:
  49.          * <ul>
  50.          *   <li>{@link #sleep Thread.sleep}</li>
  51.          *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
  52.          *   <li>{@link #join(long) Thread.join} with timeout</li>
  53.          *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
  54.          *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
  55.          * </ul>
  56.          */
  57.     TIMED_WAITING,
  59.     /**
  60.          * Thread state for a terminated thread.
  61.          * The thread has completed execution.
  62.          */
  63.     TERMINATED;
  64. }

查看线程当前状态

  1. public class Main {
  2.     public static void main(String[] args) {
  3.         Task task = new Task();
  4.         task.setName("铸剑计划");
  6.         System.out.println(task.getState());
  7.         task.start();
  8.         System.out.println(task.getState());
  10.         while (task.getState() != Thread.State.TERMINATED){
  11.             System.out.println(task.getState());
  13.             try {
  14.                 Thread.sleep(500);
  15.             } catch (InterruptedException e) {
  16.                 e.printStackTrace();
  17.             }
  18.         }
  20.         System.out.println(task.getState());
  21.     }
  22. }
  24. class Task extends Thread {
  25.     @Override
  26.     public void run() {
  27.         for (int i = 0; i < 3; i++) {
  28.             try {
  29.                 sleep(1000);
  30.             } catch (InterruptedException e) {
  31.                 e.printStackTrace();
  32.             }
  33.             System.out.println(getName() + ": " + i);
  34.         }
  35.     }
  36. }