MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java 线程池状态的终止状态

2023-01-283.5k 阅读

Java 线程池状态概述

在 Java 并发编程中，线程池是一种非常重要的工具，它允许我们复用线程，提高应用程序的性能和资源利用率。Java 的 ThreadPoolExecutor 类实现了线程池的功能，并且定义了几种不同的状态来表示线程池的运行情况。线程池的状态对于理解线程池的工作原理以及调试多线程应用程序至关重要。

ThreadPoolExecutor 类定义了以下几种状态：

  1. RUNNING：这是线程池的初始状态，线程池可以接受新任务并处理队列中的任务。
  2. SHUTDOWN：调用 shutdown() 方法后，线程池进入此状态。线程池不再接受新任务，但会继续处理队列中已有的任务。
  3. STOP：调用 shutdownNow() 方法后，线程池进入此状态。线程池会停止接受新任务，并且尝试停止正在执行的任务，同时会清空任务队列。
  4. TIDYING：当所有任务都已完成，并且工作线程数为 0 时，线程池进入此状态。
  5. TERMINATED：这是线程池的终止状态，当 terminated() 钩子方法执行完毕后，线程池进入此状态。

本文将重点讨论线程池的终止状态，即从 TIDYING 到 TERMINATED 的转变以及相关的原理和应用。

终止状态的转变过程

当线程池中的所有任务都已完成，并且工作线程数降为 0 时，线程池会进入 TIDYING 状态。此时，线程池会调用 terminated() 方法，这是一个钩子方法，用户可以在子类中重写此方法以执行一些清理操作。当 terminated() 方法执行完毕后，线程池最终进入 TERMINATED 状态。

从任务完成到 TIDYING 状态

在 ThreadPoolExecutor 的实现中，当一个工作线程完成任务后，会调用 processWorkerExit() 方法。这个方法会减少工作线程的数量，并检查是否所有任务都已完成以及工作线程数是否为 0。如果满足这两个条件，线程池就会进入 TIDYING 状态。下面是简化的 processWorkerExit() 方法代码片段：

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly)
        decrementWorkerCount();
    else
        // 如果任务正常完成，减少工作线程数
        tryTerminate();
    // 其他清理操作
}

final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN &&!workQueue.isEmpty()))
            return;
        if (workerCountOf(c) != 0) // 还有工作线程在运行
            return;
        if (ctl.compareAndSet(c, ctlOf(SHUTDOWN, 0))) {
            try {
                terminated();
            } finally {
                ctl.set(ctlOf(TIDYING, 0));
                terminated();
            }
            break;
        }
    }
}

在 tryTerminate() 方法中，首先会检查线程池的状态是否为 RUNNING，或者已经处于 TIDYING 或 TERMINATED 状态，或者在 SHUTDOWN 状态下任务队列不为空。如果满足这些条件之一，就直接返回，不进入 TIDYING 状态。然后检查工作线程数是否为 0，如果不为 0 也返回。只有当所有条件都不满足时，才会尝试将线程池状态设置为 TIDYING，并调用 terminated() 方法。

从 TIDYING 到 TERMINATED 状态

在 tryTerminate() 方法中，当成功将线程池状态设置为 TIDYING 后，会调用 terminated() 方法。terminated() 方法默认是空实现，用户可以在子类中重写此方法来执行一些自定义的清理操作，比如关闭数据库连接、释放资源等。当 terminated() 方法执行完毕后，线程池会将状态设置为 TERMINATED。

protected void terminated() { }

终止状态的应用场景

了解线程池的终止状态在实际应用中有很多好处，下面列举几个常见的应用场景。

资源清理

在多线程应用程序中，线程池可能会使用一些外部资源，如数据库连接、文件句柄等。当线程池终止时，需要正确地清理这些资源，以避免资源泄漏。通过重写 terminated() 方法，我们可以在其中执行资源清理操作。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CustomThreadPool extends ThreadPoolExecutor {

    // 假设这是一个数据库连接对象
    private DatabaseConnection connection;

    public CustomThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                            BlockingQueue<Runnable> workQueue, DatabaseConnection connection) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        this.connection = connection;
    }

    @Override
    protected void terminated() {
        // 关闭数据库连接
        if (connection != null) {
            connection.close();
        }
        System.out.println("线程池已终止，数据库连接已关闭");
    }

    public static class DatabaseConnection {
        public void close() {
            System.out.println("关闭数据库连接");
        }
    }

    public static void main(String[] args) {
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
        DatabaseConnection connection = new DatabaseConnection();
        CustomThreadPool executor = new CustomThreadPool(2, 4, 10, TimeUnit.SECONDS, workQueue, connection);

        executor.submit(() -> {
            System.out.println("任务执行中");
        });

        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    System.err.println("Pool did not terminate");
                }
            }
        } catch (InterruptedException ie) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

在上述代码中，CustomThreadPool 继承自 ThreadPoolExecutor，并重写了 terminated() 方法。在 terminated() 方法中，关闭了数据库连接。当线程池终止时，会自动调用 terminated() 方法，从而确保数据库连接被正确关闭。

等待线程池终止

在一些应用场景中，我们可能需要等待线程池中的所有任务执行完毕，并且线程池完全终止后再执行后续操作。可以通过调用 awaitTermination() 方法来实现这一点。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class WaitForThreadPoolTermination {

    public static void main(String[] args) {
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 10, TimeUnit.SECONDS, workQueue);

        executor.submit(() -> {
            System.out.println("任务执行中");
        });

        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    System.err.println("Pool did not terminate");
                }
            }
            System.out.println("线程池已终止");
        } catch (InterruptedException ie) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

在上述代码中，调用 executor.shutdown() 后，通过 awaitTermination() 方法等待线程池终止。如果在指定的时间内线程池没有终止，则调用 shutdownNow() 尝试强制终止，并再次等待。这种方式可以确保在程序退出前，线程池中的所有任务都已完成。

监控线程池状态

通过了解线程池的终止状态，我们可以更好地监控线程池的运行情况。例如，可以定期检查线程池的状态，当发现线程池进入 TERMINATED 状态时，记录相关日志或进行一些统计分析。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MonitorThreadPoolState {

    public static void main(String[] args) {
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 10, TimeUnit.SECONDS, workQueue);

        executor.submit(() -> {
            System.out.println("任务执行中");
        });

        executor.shutdown();

        new Thread(() -> {
            while (!executor.isTerminated()) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println("线程池状态: " + executor.getState());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("线程池已终止");
        }).start();

        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    System.err.println("Pool did not terminate");
                }
            }
        } catch (InterruptedException ie) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

在上述代码中，启动了一个新线程来定期检查线程池的状态。通过 executor.getState() 方法获取线程池的当前状态，并输出到控制台。这样可以实时了解线程池的运行情况，有助于调试和性能优化。

终止状态相关的注意事项

在使用线程池的终止状态时，有一些注意事项需要牢记。

正确处理任务异常

在多线程环境下，任务执行过程中可能会抛出异常。如果不妥善处理这些异常，可能会导致线程提前终止，影响线程池的正常运行。ThreadPoolExecutor 默认不会捕获任务中的异常，因此需要在任务中自行处理异常，或者使用 Future 来获取任务执行结果并处理异常。

import java.util.concurrent.*;

public class HandleTaskException {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Future<?> future = executor.submit(() -> {
            throw new RuntimeException("任务执行出错");
        });

        try {
            future.get();
        } catch (InterruptedException | ExecutionException e) {
            System.err.println("捕获到任务异常: " + e.getCause());
        }

        executor.shutdown();
    }
}

在上述代码中，通过 Future 的 get() 方法获取任务执行结果，并捕获可能抛出的异常。这样可以确保任务异常不会影响线程池的正常终止。

避免死锁

在多线程编程中，死锁是一个常见的问题。当线程池中的任务相互等待对方释放资源时，就可能发生死锁。为了避免死锁，需要合理设计任务的执行逻辑，确保资源的获取和释放顺序一致。

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

public class AvoidDeadlock {

    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.submit(() -> {
            synchronized (lock1) {
                System.out.println("线程 1 获取 lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (lock2) {
                    System.out.println("线程 1 获取 lock2");
                }
            }
        });

        executor.submit(() -> {
            synchronized (lock2) {
                System.out.println("线程 2 获取 lock2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                synchronized (lock1) {
                    System.out.println("线程 2 获取 lock1");
                }
            }
        });

        executor.shutdown();
    }
}

在上述代码中，两个任务获取锁的顺序是一致的，从而避免了死锁的发生。在实际应用中，需要仔细分析任务之间的资源依赖关系，确保不会出现死锁情况。

合理设置线程池参数

线程池的参数设置对其性能和终止状态有很大影响。例如，corePoolSize、maximumPoolSize 和 keepAliveTime 等参数会影响线程池的工作线程数量和任务处理能力。如果设置不当，可能会导致线程池过早或过晚终止，影响应用程序的性能。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class OptimizeThreadPoolParameters {

    public static void main(String[] args) {
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
        // 合理设置核心线程数和最大线程数
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 4, 10, TimeUnit.SECONDS, workQueue);

        executor.submit(() -> {
            System.out.println("任务执行中");
        });

        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                    System.err.println("Pool did not terminate");
                }
            }
        } catch (InterruptedException ie) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

在上述代码中，根据任务的特点和系统资源情况，合理设置了 corePoolSize 和 maximumPoolSize。在实际应用中，需要通过性能测试和调优来确定最佳的线程池参数。

总结

Java 线程池的终止状态是多线程编程中一个重要的概念，理解从 TIDYING 到 TERMINATED 的转变过程以及相关的应用场景和注意事项，对于编写高效、稳定的多线程应用程序至关重要。通过合理利用线程池的终止状态，我们可以实现资源清理、等待线程池终止、监控线程池状态等功能，同时避免任务异常、死锁等问题，提高应用程序的性能和可靠性。在实际开发中，需要根据具体的业务需求和系统环境，灵活运用线程池的特性，以达到最佳的效果。