Java 简明教程

Java - Thread Life Cycle

Life Cycle of a Thread in Java

Java 中线程的生命周期是指线程所经历的各种状态。例如，一个线程会诞生、启动、运行，然后死亡。 Thread class 定义了线程的生命周期和各种状态。

The life cycle of a thread in Java refers to the various states of a thread goes through. For example, a thread is born, started, runs, and then dies. Thread class defines the life cycle and various states of a thread.

Flow Chart of Java Thread Life Cycle

以下图表显示了线程的完整生命周期。

The following diagram shows the complete life cycle of a thread.

thread life cycle

States of a Thread Life Cycle in Java

以下是生命周期的阶段 -

Following are the stages of the life cycle −

  1. New − A new thread begins its life cycle in the new state. It remains in this state until the program starts the thread. It is also referred to as a born thread.

  2. Runnable − After a newly born thread is started, the thread becomes runnable. A thread in this state is considered to be executing its task.

  3. Waiting − Sometimes, a thread transitions to the waiting state while the thread waits for another thread to perform a task. A thread transitions back to the runnable state only when another thread signals the waiting thread to continue executing.

  4. Timed Waiting − A runnable thread can enter the timed waiting state for a specified interval of time. A thread in this state transitions back to the runnable state when that time interval expires or when the event it is waiting for occurs.

  5. Terminated (Dead) − A runnable thread enters the terminated state when it completes its task or otherwise terminates.

Java Example for Demonstrating Thread States

在该示例中，我们通过扩展 Thread 类来创建两个线程。我们正在打印线程的各个状态。当创建一个线程对象时，它的状态为 NEW；当调用 start() method 时，状态为 START；当调用 run() method 时，状态为 RUNNING；当一个线程完成处理 run() 方法时，它会转到 DEAD 状态。

In this example, we’re creating two threads by extending the Thread class. We’re printing each state of the thread. When a thread object is created, its state is NEW; when start() method is called, state is START; when run() method is called, state is RUNNING; When a thread finished the processing the run() method, it went to DEAD state.

package com.tutorialspoint;
class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Thread: " + threadName + ", " + "State: New");
   }
   public void run() {
      System.out.println("Thread: " + threadName + ", " + "State: Running");
      for(int i = 4; i > 0; i--) {
         System.out.println("Thread: " + threadName + ", " + i);
      }
      System.out.println("Thread: " + threadName + ", " + "State: Dead");
   }
   public void start () {
      System.out.println("Thread: " + threadName + ", " + "State: Start");
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
public class TestThread {
   public static void main(String args[]) {
      ThreadDemo thread1 = new ThreadDemo( "Thread-1");
      ThreadDemo thread2 = new ThreadDemo( "Thread-2");
      thread1.start();
      thread2.start();
   }
}
Thread: Thread-1, State: New
Thread: Thread-2, State: New
Thread: Thread-1, State: Start
Thread: Thread-2, State: Start
Thread: Thread-1, State: Running
Thread: Thread-2, State: Running
Thread: Thread-2, 4
Thread: Thread-2, 3
Thread: Thread-2, 2
Thread: Thread-2, 1
Thread: Thread-2, State: Dead
Thread: Thread-1, 4
Thread: Thread-1, 3
Thread: Thread-1, 2
Thread: Thread-1, 1
Thread: Thread-1, State: Dead

More Examples on Thread Life Cycle & States

Example 1

在该示例中，我们正在使用 sleep() method 来引入处理的某些延迟，并且要演示使用线程的并行处理。我们正在通过扩展 Thread 类来创建两个线程。我们正在打印线程的各个状态。当创建一个线程对象时，它的状态为 NEW；当调用 start() 方法时，状态为 START；当调用 run() 方法时，状态为 RUNNING；如果调用了 sleep()，那么线程会转到 WAITING 状态；当一个线程完成处理 run() 方法时，它会转到 DEAD 状态。

In this example,we’re using sleep() method to introduce some delay in processing and to show case the parallel processing using threads. We’re creating two threads by extending the Thread class. We’re printing each state of the thread. When a thread object is created, its state is NEW; when start() method is called, state is START; when run() method is called, state is RUNNING; in case sleep() is called, then thread goes to WAITING state; When a thread finished the processing the run() method, it went to DEAD state.

package com.tutorialspoint;
class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Thread: " + threadName + ", " + "State: New");
   }
   public void run() {
      System.out.println("Thread: " + threadName + ", " + "State: Running");
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            System.out.println("Thread: " + threadName + ", " + "State: Waiting");
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread: " + threadName + ", " + "State: Dead");
   }

   public void start () {
      System.out.println("Thread: " + threadName + ", " + "State: Start");
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
public class TestThread {
   public static void main(String args[]) {
      ThreadDemo thread1 = new ThreadDemo( "Thread-1");
      ThreadDemo thread2 = new ThreadDemo( "Thread-2");
      thread1.start();
      thread2.start();
   }
}
Thread: Thread-1, State: New
Thread: Thread-2, State: New
Thread: Thread-1, State: Start
Thread: Thread-2, State: Start
Thread: Thread-1, State: Running
Thread: Thread-1, 4
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Running
Thread: Thread-2, 4
Thread: Thread-2, State: Waiting
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-2, State: Waiting
Thread: Thread-1, State: Waiting
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Waiting
Thread: Thread-2, 1
Thread: Thread-2, State: Waiting
Thread: Thread-1, 1
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Dead
Thread: Thread-1, State: Dead

Example 2

在此示例中，我们通过实现 Runnable 类来创建两个线程。我们正在打印线程的每个状态。当创建线程对象时，它的状态为 NEW；当调用 start() 方法时，状态为 START；当调用 run() 方法时，状态为 RUNNING；如果调用了 sleep()，则线程将转到 WAITING 状态；当线程完成 run() 方法的处理时，它将转到 DEAD 状态。

In this example, we’re creating two threads by implementing the Runnable class. We’re printing each state of the thread. When a thread object is created, its state is NEW; when start() method is called, state is START; when run() method is called, state is RUNNING; in case sleep() is called, then thread goes to WAITING state; When a thread finished the processing the run() method, it went to DEAD state.

package com.tutorialspoint;
class ThreadDemo implements Runnable {
   private Thread t;
   private String threadName;
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Thread: " + threadName + ", " + "State: New");
   }
   public void run() {
      System.out.println("Thread: " + threadName + ", " + "State: Running");
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            System.out.println("Thread: " + threadName + ", " + "State: Waiting");
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread: " + threadName + ", " + "State: Dead");
   }

   public void start () {
      System.out.println("Thread: " + threadName + ", " + "State: Start");
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
public class TestThread {
   public static void main(String args[]) {
      ThreadDemo thread1 = new ThreadDemo( "Thread-1");
      ThreadDemo thread2 = new ThreadDemo( "Thread-2");
      thread1.start();
      thread2.start();
   }
}
Thread: Thread-1, State: New
Thread: Thread-2, State: New
Thread: Thread-1, State: Start
Thread: Thread-2, State: Start
Thread: Thread-1, State: Running
Thread: Thread-1, 4
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Running
Thread: Thread-2, 4
Thread: Thread-2, State: Waiting
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-2, State: Waiting
Thread: Thread-1, State: Waiting
Thread: Thread-2, 2
Thread: Thread-1, 2
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Waiting
Thread: Thread-2, 1
Thread: Thread-2, State: Waiting
Thread: Thread-1, 1
Thread: Thread-1, State: Waiting
Thread: Thread-2, State: Dead
Thread: Thread-1, State: Dead