Java 线程的生命周期详细介绍及实例代码

Java 线程是 Java 编程中一个非常重要的概念。线程的生命周期指的是一个线程从被创建到最终死亡的整个过程，在这个过程中，线程会经历不同的阶段。

线程的生命周期

Java 线程的生命周期分为 6 个阶段，分别是：

1. 新建状态（New）： 当一个线程对象被创建后，它就处于新建状态。此时，线程没有被系统启动，它不具有执行的能力。

2. 就绪状态（Runnable）： 当一个线程调用 start() 方法后，该线程就处于就绪状态。此时，线程具有了执行的能力，只是还没有被启动执行。此时，线程会被加入就绪队列中，等待系统进行调度。

3. 运行状态（Running）： 当线程调度器选择了一个线程，使它进入运行状态时，它才真正开始执行。处于运行状态的线程可以转换到就绪状态或者阻塞状态。

4. 阻塞状态（Blocked）： 当一个正在执行的线程被挂起时，它就处于阻塞状态。在阻塞状态下，线程不会占用 CPU 资源，因此也不会消耗系统资源。线程被唤醒后，将会回到就绪状态。

5. 等待状态（Waiting）： 线程进入等待状态时，它将不会被分配 CPU 时间，也不会运行任何代码。在等待状态下，线程只会等待某些条件的发生，例如，等待其他线程的执行结果或者等待某个对象锁的释放。

6. 死亡状态（Terminated）： 当线程的 run() 方法执行完毕，或者出现了异常而没有被处理时，线程进入死亡状态。

Java 线程的示例说明

示例一

下面是一个 Java 线程的代码示例：

public class MyThread extends Thread {
   public void run() {
      System.out.println("线程运行中...");
   }

   public static void main(String args[]) {
      MyThread thread = new MyThread();
      thread.start();
   }
}

在这个示例中，我们创建了一个继承自 Thread 类的子类 MyThread，该子类重载了 run() 方法。在 main 方法中，我们创建了 MyThread 的实例并调用了 start() 方法。在这个过程中，MyThread 的状态从 new 变为了 Runnable，然后进入运行状态，执行了 run() 方法中的代码。

示例二

下面是一个 Java 线程等待的示例代码：

class WaitNotifyDemo {
   public void testWait() throws InterruptedException {
      synchronized (this) {
         System.out.println(Thread.currentThread().getName() + "线程开始执行...");
         wait();
         System.out.println(Thread.currentThread().getName() + "线程等待结束...");
      }
   }

   public void testNotify() throws InterruptedException {
      Thread.sleep(1000);
      synchronized (this) {
         System.out.println(Thread.currentThread().getName() + "线程开始执行...");
         notify();
         System.out.println(Thread.currentThread().getName() + "线程执行结束...");
      }
   }

   public static void main(String[] args) {
      WaitNotifyDemo demo = new WaitNotifyDemo();

      new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               demo.testWait();
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }, "等待线程").start();

      new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               demo.testNotify();
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      }, "通知线程").start();
   }
}

在这个示例中，我们创建了 WaitNotifyDemo 类，并实现了两个测试方法 testWait() 和 testNotify()。在主线程中，我们分别启动了等待线程和通知线程。在等待线程中，我们使用 synchronized 来加锁，并调用 wait() 方法让线程等待状态；在通知线程中，我们也使用 synchronized 来加锁，并调用 notify() 方法来通知等待线程。

在等待线程开始执行后，它会进入等待状态。在通知线程执行完毕后，它会唤醒等待线程并让它执行。在这个过程中，等待线程的状态会经历从 Runnable 转换为 Waiting，然后再转换为 Runnable。