Java 线程生命周期：深入理解与实践
简介
在 Java 多线程编程中，线程的生命周期是一个核心概念。理解线程从创建到销毁的各个阶段，对于编写高效、稳定且正确的多线程程序至关重要。本文将详细探讨 Java 线程的生命周期，包括基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这一关键技术。
目录
- 基础概念
- 线程生命周期阶段
- 状态转换关系
- 使用方法
- 创建线程
- 启动线程
- 控制线程状态
- 常见实践
- 线程同步
- 线程池的使用
- 最佳实践
- 避免死锁
- 合理使用线程资源
- 小结
- 参考资料
基础概念
线程生命周期阶段
Java 线程的生命周期包含以下几个阶段：
1. 新建（New）：当创建一个 Thread 类的实例时，线程处于新建状态。此时线程还未开始运行。
2. 就绪（Runnable）：调用 start() 方法后，线程进入就绪状态。处于就绪状态的线程已经具备了运行的条件，但还没有分配到 CPU 资源，等待被调度执行。
3. 运行（Running）：当线程被调度器选中并分配到 CPU 资源时，线程进入运行状态，开始执行 run() 方法中的代码。
4. 阻塞（Blocked）：在运行过程中，线程可能会因为某些原因进入阻塞状态，比如等待获取锁、调用 sleep() 方法、等待输入输出完成等。处于阻塞状态的线程不会占用 CPU 资源。
5. 等待（Waiting）：线程可以通过调用 Object 类的 wait() 方法、Thread 类的 join() 方法等进入等待状态。处于等待状态的线程需要其他线程的通知才能继续执行。
6. 计时等待（Timed Waiting）：与等待状态类似，但有一个指定的等待时间。例如，调用 Thread.sleep(long millis) 或 Object.wait(long timeout) 方法会使线程进入计时等待状态，等待指定的时间后自动唤醒。
7. 终止（Terminated）：当线程的 run() 方法执行完毕或者抛出未捕获的异常时，线程进入终止状态，生命周期结束。
状态转换关系
不同状态之间的转换关系如下：
- 新建 -> 就绪：调用 start() 方法。
- 就绪 -> 运行：线程调度器选中该线程。
- 运行 -> 阻塞：等待获取锁、调用 sleep() 方法等。
- 运行 -> 等待：调用 Object.wait() 或 Thread.join() 等方法。
- 运行 -> 计时等待：调用 Thread.sleep(long millis) 或 Object.wait(long timeout) 等方法。
- 阻塞 -> 就绪：获取到锁或等待条件满足。
- 等待 -> 就绪：其他线程调用 Object.notify() 或 Object.notifyAll() 方法通知。
- 计时等待 -> 就绪：等待时间结束或收到通知。
- 运行/阻塞/等待/计时等待 -> 终止：run() 方法执行完毕或抛出未捕获的异常。
使用方法
创建线程
在 Java 中，创建线程有两种常见方式：继承 Thread 类和实现 Runnable 接口。
继承 Thread 类
class MyThread extends Thread {
@Override
public void run() {
System.out.println("This is a thread extending Thread class.");
}
}
public class ThreadExample1 {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
}
}
实现 Runnable 接口
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("This is a thread implementing Runnable interface.");
}
}
public class ThreadExample2 {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
}
}
启动线程
创建线程实例后，调用 start() 方法启动线程。start() 方法会使线程进入就绪状态，等待线程调度器调度执行。
控制线程状态
- 暂停线程：可以使用
Thread.sleep(long millis)方法使当前线程暂停指定的毫秒数。
public class SleepExample {
public static void main(String[] args) {
try {
System.out.println("Before sleep");
Thread.sleep(2000); // 暂停 2 秒
System.out.println("After sleep");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
- 等待线程结束：使用
join()方法可以使当前线程等待调用该方法的线程执行完毕。
public class JoinExample {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
try {
Thread.sleep(3000);
System.out.println("Thread finished");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
thread.start();
try {
System.out.println("Waiting for thread to finish");
thread.join();
System.out.println("Thread has finished");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
常见实践
线程同步
在多线程环境下，多个线程可能同时访问共享资源，这可能导致数据不一致等问题。通过线程同步机制可以解决这些问题。
使用 synchronized 关键字
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
}
public class SynchronizedExample {
public static void main(String[] args) {
Counter counter = new Counter();
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Final count: " + counter.getCount());
}
}
使用 ReentrantLock
import java.util.concurrent.locks.ReentrantLock;
class Counter2 {
private int count = 0;
private ReentrantLock lock = new ReentrantLock();
public void increment() {
lock.lock();
try {
count++;
} finally {
lock.unlock();
}
}
public int getCount() {
return count;
}
}
public class ReentrantLockExample {
public static void main(String[] args) {
Counter2 counter = new Counter2();
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
counter.increment();
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Final count: " + counter.getCount());
}
}
线程池的使用
线程池可以有效地管理和复用线程，减少线程创建和销毁的开销。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("Task " + taskId + " is running.");
}
}
public class ThreadPoolExample {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(3);
for (int i = 1; i <= 5; i++) {
Task task = new Task(i);
executorService.submit(task);
}
executorService.shutdown();
}
}
最佳实践
避免死锁
死锁是多线程编程中常见的问题，当两个或多个线程相互等待对方释放锁时就会发生死锁。为了避免死锁，应遵循以下原则：
- 尽量减少锁的使用范围。
- 按照相同的顺序获取锁。
- 使用定时锁（如 tryLock() 方法）。
合理使用线程资源
- 避免创建过多线程，以免耗尽系统资源。
- 合理设置线程优先级，但不要过度依赖优先级来控制线程执行顺序。
小结
本文详细介绍了 Java 线程的生命周期，包括各个阶段的概念、状态转换关系，以及线程的创建、启动和控制方法。同时，还探讨了线程同步和线程池等常见实践，并给出了避免死锁和合理使用线程资源的最佳实践。通过深入理解和运用这些知识，读者能够编写出更加健壮、高效的多线程程序。
参考资料
- Oracle Java 官方文档
- 《Effective Java》 by Joshua Bloch
- 《Java Concurrency in Practice》 by Brian Goetz et al.