Java线程生命周期及转换过程

前言：

线程的生命周期指的是线程从创建到销毁的整个过程，通常情况下线程的生命周期有以下 5 种：

• 初始状态

• 可运行状态

• 运行状态

• 休眠状态

• 终止状态

它们的状态转换如下图所示： 

Java 线程生命周期

Java 线程的生命周期和上面说的生命周期是不同的，它有以下 6 种状态：

• NEW（初始化状态）

• RUNNABLE（可运行/运行状态）

• BLOCKED（阻塞状态）

• WAITING（无时限等待状态）

• TIMED_WAITING（有时限等待状态）

• TERMINATED（终止状态）

我们可以在 Thread 的源码中可以找到这 6 种状态，如下所示： 

 当然你也可以使用 Java 代码，来打印所有的线程状态，如下代码所示：

for (Thread.State value : Thread.State.values()) {
   System.out.println(value);
}

以上程序的执行结果如下图所示： 

生命周期转换

接下来我们聊聊 Java 线程生命周期的转换过程。

1.从 NEW 到 RUNNABLE

当我们创建一个线程的时候，也就是 new Thread 的时候，此时线程是 NEW 状态，如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
       // ...
   }
});
// 获取线程状态
Thread.State state = thread.getState();
System.out.println(state);

以上程序的执行结果如下图所示： 

 然而调用了线程的 start 方法之后，线程的状态就从 NEW 变成了 RUNNABLE，

如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
       // 获取到当前执行的线程
       Thread currThread = Thread.currentThread();
       // 获取线程状态
       Thread.State state = currThread.getState();
       // 打印线程状态
       System.out.println(state);
   }
});
thread.start();

以上程序的执行结果如下图所示： 

2.从 RUNNABLE 到 BLOCKED

当线程中的代码排队执行 synchronized 时，线程就会从 RUNNABLE 状态变为 BLOCKED 阻塞状态

如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
       try {
           // 等待 100 毫秒
           Thread.sleep(100);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("排队使用锁");
       synchronized (ThreadStates.class) {
       }
   }
});
thread.start();
// 让主线程先得到锁
synchronized (ThreadStates.class) {
   // 获取线程状态
   Thread.State state = thread.getState();
   // 打印线程状态
   System.out.println("首次获取线程状态：" + state);
   // 休眠 1s
   try {
       Thread.sleep(1000);
   } catch (InterruptedException e) {
       e.printStackTrace();
   }
   // 再次获取线程状态
   state = thread.getState();
   // 打印线程状态
   System.out.println("第二次获取线程状态：" + state);
}

以上程序的执行结果如下图所示： 

 当线程获取到 synchronized 锁之后，就会从 BLOCKED 状态转变为 RUNNABLE 状态。

3.从 RUNNABLE 到 WAITTING

线程调用 wait() 方法之后，就会从 RUNNABLE 状态变为 WAITING 无时限等待状态，如下所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
       synchronized (this) {
           try {
               // 线程休眠
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态：" + state);
// 休眠 1s
try {
   Thread.sleep(1000);
} catch (InterruptedException e) {
   e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态：" + state);

以上程序的执行结果如下图所示： 

 当调用了 notify/notifyAll 方法之后，线程会从 WAITING 状态变成 RUNNABLE 状态，

如下代码所示：

Object lock = new Object();
// 创建线程
Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
       synchronized (lock) {
           try {
               // 线程休眠
               lock.wait();
               // 获取当前线程状态
               Thread.State state = Thread.currentThread().getState();
               // 打印线程状态
               System.out.println("获取线程状态：" + state);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态：" + state);
// 休眠 1s
try {
   Thread.sleep(100);
} catch (InterruptedException e) {
   e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态：" + state);

// 唤醒 thread 线程
synchronized (lock) {
   lock.notify();
}

以上程序的执行结果如下图所示： 

4.从 RUNNABLE 到 TIMED_WATTING

当调用带超时时间的等待方法时，如 sleep(xxx)，线程会从 RUNNABLE 状态变成 TIMED_WAITING 有时限状态，

如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态：" + state);
// 休眠 1s
try {
   Thread.sleep(100);
} catch (InterruptedException e) {
   e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态：" + state);

以上程序的执行结果如下图所示： 

 当超过了超时时间之后，线程就会从 TIMED_WAITING 状态变成 RUNNABLE 状态，

实现代码如下：

// 创建线程
Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
       try {
           Thread.sleep(1000);
           // 获取当前线程状态
           Thread.State state = Thread.currentThread().getState();
           // 打印线程状态
           System.out.println("获取线程状态：" + state);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
   }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态：" + state);
// 休眠 1s
try {
   Thread.sleep(100);
} catch (InterruptedException e) {
   e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态：" + state);

以上程序的执行结果如下图所示： 

5.RUNNABLE 到 TERMINATED

线程执行完之后，就会从 RUNNABLE 状态变成 TERMINATED 销毁状态，如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
   @Override
   public void run() {
       // 获取当前线程状态
       Thread.State state = Thread.currentThread().getState();
       // 打印线程状态
       System.out.println("获取线程状态：" + state);
   }
});
// 启动线程
thread.start();
// 等待 100ms，待线程执行完
Thread.sleep(100);
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("线程状态：" + state);

以上程序的执行结果如下图所示： 

来源：https://juejin.cn/post/7065856076737937438