Java 线程的生命周期管理

引言

线程是 Java 编程中重要的概念之一。通过多线程，程序可以同时执行多个任务，提高效率和响应能力。理解和管理线程的生命周期是编写高效并发程序的关键。本文将详细介绍 Java 线程的生命周期管理，并解释几种关键方法：start()、sleep(long millis)、join()、yield() 和 interrupt()。

线程的生命周期

Java 线程的生命周期可以分为五个主要阶段：

1. 新建（New）：线程对象被创建，但尚未调用 start() 方法。
2. 就绪（Runnable）：线程对象调用了 start() 方法，等待 CPU 调度执行。
3. 运行（Running）：线程获得 CPU 资源，开始执行 run() 方法。
4. 阻塞（Blocked）：线程因为某种原因（如等待资源）暂时停止执行。
5. 死亡（Dead）：线程执行完 run() 方法或被终止，进入死亡状态。

线程的生命周期管理方法

start(): 启动线程

start() 方法用于启动线程，它将线程从新建状态转移到就绪状态，并等待 CPU 调度执行。调用 start() 方法后，JVM 会调用线程的 run() 方法。

public class StartExample extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        StartExample thread = new StartExample();
        thread.start(); // 启动线程
    }
}

sleep(long millis): 使线程休眠指定的时间

Thread.sleep(long millis) 方法使当前线程暂停执行一段时间（以毫秒为单位），进入阻塞状态。这对模拟延时或控制线程执行的节奏非常有用。

public class SleepExample extends Thread {
    @Override
    public void run() {
        try {
            System.out.println("Thread is going to sleep");
            Thread.sleep(2000); // 休眠2秒
            System.out.println("Thread is awake");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

join(): 等待线程终止

join() 方法使当前线程等待调用 join() 的线程执行完毕再继续执行。这在需要确保某个线程完成其任务后再执行其他任务时非常有用。

public class JoinExample extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        JoinExample thread = new JoinExample();
        thread.start();
        try {
            thread.join(); // 等待 thread 执行完毕
            System.out.println("Thread has finished");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

yield(): 暂停当前正在执行的线程对象，并执行其他线程

Thread.yield() 方法使当前正在执行的线程让出 CPU 资源，但不会进入阻塞状态，仍然处于就绪状态。这有助于提高 CPU 使用效率，让其他同优先级的线程有机会执行。

public class YieldExample extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " - " + i);
            Thread.yield(); // 让出 CPU 资源
        }
    }

    public static void main(String[] args) {
        YieldExample thread1 = new YieldExample();
        YieldExample thread2 = new YieldExample();
        thread1.start();
        thread2.start();
    }
}

interrupt(): 中断线程

interrupt() 方法用于中断线程。当一个线程被中断时，如果它处于阻塞状态（例如在调用 sleep() 方法时），会抛出 InterruptedException 异常；如果它没有处于阻塞状态，则会设置线程的中断标志。

public class InterruptExample extends Thread {
    @Override
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running");
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println("Thread was interrupted");
        }
    }

    public static void main(String[] args) {
        InterruptExample thread = new InterruptExample();
        thread.start();
        try {
            Thread.sleep(3000); // 主线程休眠3秒
            thread.interrupt(); // 中断子线程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结论

Java 提供了多种方法来管理线程的生命周期，包括 start()、sleep(long millis)、join()、yield() 和 interrupt()。通过理解和正确使用这些方法，可以有效地控制线程的执行，提高程序的并发性能。