游牧学院

9.1 线程的创建与运行
9.3 线程同步与锁机制

Java 多线程编程：线程的生命周期

在 Java 中，多线程编程是实现并发执行的关键。线程的生命周期是理解多线程编程的基础，掌握线程的不同状态及其转换对于编写高效、稳定的多线程程序至关重要。本文将详细介绍 Java 线程的生命周期，包括每个状态的定义、状态之间的转换、优缺点以及注意事项，并提供丰富的示例代码。

1. 线程的生命周期概述

Java 中的线程生命周期主要包括以下几种状态：

  1. 新建状态（New）
  2. 就绪状态（Runnable）
  3. 运行状态（Running）
  4. 阻塞状态（Blocked）
  5. 等待状态（Waiting）
  6. 超时等待状态（Timed Waiting）
  7. 死亡状态（Terminated）

1.1 新建状态（New）

当一个线程对象被创建时，它处于新建状态。此时，线程尚未开始执行。

public class NewStateExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });
        // 线程处于新建状态
        System.out.println("Thread state: " + thread.getState());
    }
}

优点：线程对象的创建非常简单，资源消耗较少。

缺点：线程尚未开始执行，无法进行任何操作。

注意事项：在新建状态下，线程的 start() 方法尚未被调用。

1.2 就绪状态（Runnable）

当调用线程的 start() 方法后，线程进入就绪状态。此时，线程已经准备好执行，但并不一定立即运行。线程调度器会根据系统的资源情况决定哪个线程获得 CPU 时间。

public class RunnableStateExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });
        thread.start(); // 线程进入就绪状态
        System.out.println("Thread state after start: " + thread.getState());
    }
}

优点：线程可以在就绪状态下等待 CPU 时间，充分利用系统资源。

缺点：线程的执行顺序不确定，可能会导致竞争条件。

注意事项：在就绪状态下，线程可能会被操作系统调度到运行状态，也可能会被挂起。

1.3 运行状态（Running）

当线程获得 CPU 时间并开始执行时，它处于运行状态。此时，线程正在执行其任务。

public class RunningStateExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });
        thread.start(); // 线程进入就绪状态
        try {
            Thread.sleep(100); // 确保线程有时间运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread state after sleep: " + thread.getState());
    }
}

优点：线程可以执行其任务，完成特定的工作。

缺点：线程在运行状态下可能会被其他线程抢占，导致上下文切换。

注意事项：在运行状态下，线程可能会因为 I/O 操作、时间片耗尽等原因被挂起。

1.4 阻塞状态（Blocked）

当一个线程试图获取一个已经被其他线程占用的锁时，它会进入阻塞状态。此时，线程无法继续执行，直到获得锁。

public class BlockedStateExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1 is holding the lock");
                try {
                    Thread.sleep(2000); // 模拟长时间持有锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 is trying to acquire the lock");
            }
        });

        thread1.start();
        try {
            Thread.sleep(100); // 确保 thread1 先获取锁
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start(); // thread2 进入阻塞状态
    }
}

优点：通过锁机制，可以有效地控制对共享资源的访问。

缺点：可能导致死锁，影响程序的性能。

注意事项：在设计多线程程序时，应尽量减少锁的持有时间，避免长时间阻塞。

1.5 等待状态（Waiting）

当一个线程调用 Object.wait()、Thread.join() 或 LockSupport.park() 方法时，它会进入等待状态。此时，线程会一直等待，直到其他线程通知它继续执行。

public class WaitingStateExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            synchronized (WaitingStateExample.class) {
                try {
                    System.out.println("Thread 1 is waiting");
                    WaitingStateExample.class.wait(); // 进入等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1 is resumed");
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (WaitingStateExample.class) {
                System.out.println("Thread 2 is notifying");
                WaitingStateExample.class.notify(); // 唤醒等待的线程
            }
        });

        thread1.start();
        Thread.sleep(100); // 确保 thread1 先进入等待状态
        thread2.start();
    }
}

优点：可以有效地控制线程之间的协作。

缺点：线程在等待状态下无法执行，可能导致资源浪费。

注意事项：确保在适当的时机调用 notify() 或 notifyAll() 方法，以避免线程长时间等待。

1.6 超时等待状态（Timed Waiting）

当线程调用 Thread.sleep(millis)、Object.wait(millis)、Thread.join(millis) 或 LockSupport.parkNanos() 等方法时，它会进入超时等待状态。线程将在指定的时间后自动返回就绪状态。

public class TimedWaitingStateExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("Thread is sleeping");
                Thread.sleep(1000); // 进入超时等待状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread is resumed");
        });

        thread.start();
        System.out.println("Thread state after sleep: " + thread.getState());
    }
}

优点：可以控制线程的等待时间，避免无限等待。

缺点：如果时间设置不当，可能导致线程过早或过晚恢复。

注意事项：合理设置超时时间，以确保线程能够及时恢复。

1.7 死亡状态（Terminated）

当线程的 run() 方法执行完毕，或者由于异常而终止时，线程进入死亡状态。此时，线程无法再被启动。

public class TerminatedStateExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });
        thread.start();
        try {
            thread.join(); // 等待线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread state after completion: " + thread.getState());
    }
}

优点：线程的生命周期结束，资源可以被回收。

缺点：无法重新启动已经死亡的线程。

注意事项：在设计程序时，注意线程的生命周期管理，避免不必要的资源浪费。

2. 线程状态转换

线程的状态之间可以通过以下方式进行转换：

  • 新建状态 → 就绪状态：调用 start() 方法。
  • 就绪状态 → 运行状态：线程调度器分配 CPU 时间。
  • 运行状态 → 阻塞状态：尝试获取锁失败。
  • 运行状态 → 等待状态：调用 wait()、join() 等方法。
  • 运行状态 → 超时等待状态：调用 sleep()、wait(millis) 等方法。
  • 阻塞状态 → 就绪状态：获取到锁。
  • 等待状态 → 就绪状态：调用 notify() 或 notifyAll()。
  • 超时等待状态 → 就绪状态：超时结束。
  • 运行状态 → 死亡状态：run() 方法执行完毕或抛出异常。

3. 总结

理解 Java 线程的生命周期是多线程编程的基础。通过掌握线程的不同状态及其转换，可以更好地设计和实现高效的多线程程序。在实际开发中，合理使用线程状态的转换，能够有效提高程序的性能和稳定性。

注意事项

  • 在多线程编程中，尽量避免死锁和资源竞争。
  • 合理设置线程的优先级，以提高系统的响应能力。
  • 使用线程池等高级抽象来管理线程，避免频繁创建和销毁线程带来的性能损耗。

通过本文的学习，相信你对 Java 线程的生命周期有了更深入的理解。希望这些知识能够帮助你在多线程编程中游刃有余。

9.1 线程的创建与运行
9.3 线程同步与锁机制