Java 线程池之FixedThreadPool-优快云博客

本文链接：https://blog.youkuaiyun.com/yimeixiaolangzai/article/details/140118289

引言

在并发编程中，线程池是一种常用的资源管理模式，用于限制并发线程的数量，优化系统性能和资源使用。Java 提供了多种类型的线程池，其中 FixedThreadPool 是一种固定大小的线程池，适用于需要固定数量线程执行任务的场景。本文将详细介绍 FixedThreadPool 的概念、使用场景、配置及示例代码。

什么是 FixedThreadPool

FixedThreadPool 是 Java 并发包（java.util.concurrent）中的一种线程池实现。它创建一个固定数量的线程来处理任务，这些线程将被复用来执行任务，直到线程池被关闭。当所有线程都在忙时，新的任务会被放入一个等待队列中，直到有空闲线程可以执行任务。

创建 FixedThreadPool

使用 Executors 工具类

可以通过 Executors 工具类的工厂方法 newFixedThreadPool 来创建一个固定大小的线程池：

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

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
        
        for (int i = 0; i < 10; i++) {
            fixedThreadPool.execute(new Task(i));
        }
        
        fixedThreadPool.shutdown();
    }
}

class Task implements Runnable {
    private final int taskId;

    public Task(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Task " + taskId + " is running by " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000); // 模拟任务执行时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

自定义线程池配置

除了使用 Executors 工具类，还可以通过 ThreadPoolExecutor 类来自定义配置线程池：

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

public class CustomFixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService customFixedThreadPool = new ThreadPoolExecutor(
            4, 4,
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>()
        );

        for (int i = 0; i < 10; i++) {
            customFixedThreadPool.execute(new Task(i));
        }

        customFixedThreadPool.shutdown();
    }
}

class Task implements Runnable {
    private final int taskId;

    public Task(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        System.out.println("Task " + taskId + " is running by " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000); // 模拟任务执行时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

工作原理

FixedThreadPool 线程池在创建时会预先启动固定数量的线程，这些线程会在任务提交后执行任务。当所有线程都在执行任务时，新的任务将被放入等待队列，直到有空闲线程可用。线程池会复用这些线程，避免了频繁创建和销毁线程的开销，提高了系统性能和资源利用率。

使用场景

适用于固定数量的并发任务

当应用程序中需要处理的并发任务数量是已知且固定时，FixedThreadPool 是一个理想的选择。它能够控制并发线程的数量，避免过多线程导致的资源耗尽。

适用于长期运行的服务

FixedThreadPool 适用于需要长期运行的服务，例如 Web 服务器或消息处理系统。在这些场景中，固定数量的线程可以提供稳定的性能和响应时间。

注意事项

合理设置线程池大小

设置线程池大小时，应根据系统资源和任务特性进行合理配置。线程池过大可能导致系统资源耗尽，过小则可能导致任务处理速度变慢。可以根据 CPU 核心数和任务的 I/O 特性来设置线程池大小，例如：

CPU 密集型任务：线程池大小可以设置为 CPU 核心数 + 1。
I/O 密集型任务：线程池大小可以设置为 CPU 核心数的 2 倍或更多。

处理任务队列中的异常

在使用 FixedThreadPool 时，应注意处理任务队列中的异常，以防止线程池中的线程意外终止。例如，可以通过捕获 Runnable 任务中的异常来确保线程继续执行其他任务：

class SafeTask implements Runnable {
    private final int taskId;

    public SafeTask(int taskId) {
        this.taskId = taskId;
    }

    @Override
    public void run() {
        try {
            System.out.println("Task " + taskId + " is running by " + Thread.currentThread().getName());
            Thread.sleep(2000); // 模拟任务执行时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            System.err.println("Task " + taskId + " encountered an error: " + e.getMessage());
        }
    }
}

优雅关闭线程池

在使用完线程池后，应调用 shutdown() 方法来优雅地关闭线程池，确保所有已提交的任务都能执行完毕：

fixedThreadPool.shutdown();
try {
    if (!fixedThreadPool.awaitTermination(60, TimeUnit.SECONDS)) {
        fixedThreadPool.shutdownNow();
    }
} catch (InterruptedException e) {
    fixedThreadPool.shutdownNow();
    Thread.currentThread().interrupt();
}