跳转至

Java 线程状态：深入理解与高效实践

简介

在 Java 多线程编程中，线程状态是一个核心概念。了解线程的不同状态以及如何在这些状态之间转换，对于编写高效、稳定且正确的多线程程序至关重要。本文将详细介绍 Java 线程状态的基础概念、使用方法、常见实践以及最佳实践，帮助读者全面掌握这一重要知识点。

目录

  1. Java 线程状态基础概念
    • 线程状态的定义
    • 线程状态的种类
  2. Java 线程状态使用方法
    • 查看线程状态
    • 控制线程状态转换
  3. Java 线程状态常见实践
    • 线程的创建与启动
    • 线程的暂停与恢复
    • 线程的终止
  4. Java 线程状态最佳实践
    • 避免死锁
    • 合理使用线程池
    • 线程安全的设计
  5. 小结

Java 线程状态基础概念

线程状态的定义

线程状态是指线程在其生命周期内所处的不同阶段。Java 中的线程状态是通过 java.lang.Thread.State 枚举来定义的，每个状态都代表了线程当前的执行情况。

线程状态的种类

Java 线程有以下六种状态： 1. NEW：线程被创建，但尚未启动。例如： java Thread thread = new Thread(() -> System.out.println("This is a new thread")); 此时 thread 处于 NEW 状态。 2. RUNNABLE：线程正在 JVM 中执行，但可能正在等待操作系统资源，如 CPU 时间片。一旦获得资源，就会实际执行线程体中的代码。 3. BLOCKED：线程正在等待一个监视器锁（通常是在进入 synchronized 块或方法时），以获取对象的锁。例如： ```java public class BlockedExample { private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

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

        thread1.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
    }
}
```
在这个例子中，`thread2` 可能会进入 `BLOCKED` 状态，等待 `lock` 对象的锁。
  1. WAITING：线程正在等待另一个线程执行特定的操作。例如，调用 Object.wait()、Thread.join() 或 LockSupport.park() 方法时，线程会进入 WAITING 状态。以下是一个使用 Object.wait() 的示例： ```java public class WaitingExample { private static final Object lock = new Object();
    public static void main(String[] args) {
    Thread thread1 = new Thread(() -> {
        synchronized (lock) {
            try {
                lock.wait();
                System.out.println("Thread 1 resumed");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });

    Thread thread2 = new Thread(() -> {
        synchronized (lock) {
            lock.notify();
            System.out.println("Thread 2 notified");
        }
    });

    thread1.start();
    try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    thread2.start();
}

    } `thread1` 调用 `lock.wait()` 后进入 `WAITING` 状态，直到 `thread2` 调用 `lock.notify()`。 5. **TIMED_WAITING**：与 `WAITING` 类似，但线程会在指定的时间内等待。例如，调用 `Thread.sleep(long millis)`、`Object.wait(long timeout)`、`Thread.join(long millis)` 或 `LockSupport.parkNanos(long nanos)`、`LockSupport.parkUntil(long deadline)` 方法时，线程会进入 `TIMED_WAITING` 状态。java public class TimedWaitingExample { public static void main(String[] args) { Thread thread = new Thread(() -> { try { Thread.sleep(2000); System.out.println("Thread woke up after 2 seconds"); } catch (InterruptedException e) { e.printStackTrace(); } }); thread.start(); } } ``thread调用Thread.sleep(2000)后进入TIMED_WAITING` 状态，2 秒后自动唤醒。 6. TERMINATED：线程已经执行完毕，无论是正常结束还是异常结束。

Java 线程状态使用方法

查看线程状态

可以通过 Thread.getState() 方法来获取线程的当前状态。例如：

public class ThreadStateCheck {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });
        System.out.println("Thread state before start: " + thread.getState());
        thread.start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread state after start: " + thread.getState());
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread state after join: " + thread.getState());
    }
}

控制线程状态转换

通过调用不同的方法，可以使线程在不同状态之间转换。例如，调用 start() 方法将线程从 NEW 转换到 RUNNABLE；调用 sleep()、wait() 等方法可以使线程进入 TIMED_WAITING 或 WAITING 状态；调用 notify()、notifyAll() 或线程执行完毕可以使线程从 WAITING 或 TIMED_WAITING 转换到 RUNNABLE 状态。

Java 线程状态常见实践

线程的创建与启动

创建线程有两种常见方式：继承 Thread 类或实现 Runnable 接口。

// 继承 Thread 类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread is running");
    }
}

// 实现 Runnable 接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable is running");
    }
}

public class ThreadCreation {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        thread1.start();

        Thread thread2 = new Thread(new MyRunnable());
        thread2.start();
    }
}

线程的暂停与恢复

在 Java 中，不推荐使用已过时的 suspend() 和 resume() 方法。更好的做法是使用 wait() 和 notify() 机制来实现线程的暂停与恢复，如前面的 WaitingExample 所示。

线程的终止

可以通过正常执行完线程体中的代码来自然终止线程。也可以通过设置标志位的方式来主动终止线程。例如：

public class ThreadTermination {
    private static volatile boolean stop = false;

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (!stop) {
                System.out.println("Thread is running");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("Thread stopped");
        });
        thread.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        stop = true;
    }
}

Java 线程状态最佳实践

避免死锁

死锁是多线程编程中常见的问题，当两个或多个线程相互等待对方释放资源时就会发生死锁。为了避免死锁，应遵循以下原则： - 尽量减少锁的使用范围，只在必要的代码块上加锁。 - 按照相同的顺序获取锁，避免嵌套锁时顺序不一致。 - 使用定时锁，如 Lock.tryLock(long timeout, TimeUnit unit)，避免无限期等待。

合理使用线程池

线程池可以有效管理线程的创建和销毁，提高性能。在使用线程池时，要根据任务的类型和数量合理配置线程池的参数，如核心线程数、最大线程数、队列容量等。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.submit(() -> {
                System.out.println(Thread.currentThread().getName() + " is running");
            });
        }
        executorService.shutdown();
    }
}

线程安全的设计

确保共享资源的访问是线程安全的。可以使用 synchronized 关键字、java.util.concurrent.atomic 包中的原子类或 java.util.concurrent.locks 包中的锁机制来保证线程安全。

小结

本文详细介绍了 Java 线程状态的基础概念、使用方法、常见实践以及最佳实践。深入理解线程状态对于编写高效、稳定且线程安全的 Java 程序至关重要。通过合理控制线程状态转换，避免常见问题，如死锁，并采用最佳实践，如合理使用线程池和确保线程安全，开发者能够编写出高质量的多线程应用程序。希望读者通过本文的学习，能够在实际项目中更好地运用 Java 线程状态相关知识。