Java 线程池参数详解与实战

1. 引言

在上一篇中，我们讲到了Java线程的特点和使用场景，Java多线程及通信方式详解-CSDN博客

今天就对Java 线程池参数再近一步进行了解。

在Java中，线程池是一组管理和复用线程的机制，它包含了一定数量的工作线程，可以用来执行异步任务，避免了为每个任务都创建和销毁线程的开销。线程池能够管理线程的生命周期，实现对线程的复用。

为什么要使用线程池？

降低资源消耗：线程的创建和销毁会消耗系统资源，线程池通过复用线程，避免了频繁创建和销毁线程的开销，减少了资源消耗。
提高性能：通过控制并发线程数量，线程池可以更有效地管理系统资源，避免了系统因过度并发而过载，提高了程序性能和响应速度。
提高响应速度：当有任务到来时，可以直接从线程池中获取空闲线程执行任务，而不需要等待新线程的创建。这可以更快地响应请求，减少任务等待时间。
统一管理：线程池提供了统一的管理接口，可以监控、调整线程池的大小和行为，方便管理和调优。
避免任务队列溢出：当系统并发请求过大时，如果任务队列满了而无法处理新的任务，线程池可以根据配置的拒绝策略来拒绝或者临时缓存任务，避免了任务队列溢出。

2. Java 线程池介绍

Java中的Executor框架是用于管理和执行任务的机制。提供了一种简单、灵活、可扩展的方式来执行异步任务，可以管理多个任务的执行，控制并发度，降低资源消耗，提高系统性能。

常用的线程池类型有以下几种：

`2.1.FixedThreadPool`（固定大小线程池）

FixedThreadPool 创建一个固定大小的线程池，线程数量固定不变。
适合处理长时间的任务，可控制最大并发数，节约系统资源。

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

public class FixedThreadPoolExample {

    public static void main(String[] args) {
        // 创建固定大小为5的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 提交任务给线程池执行
        for (int i = 0; i < 10; i++) {
            Runnable task = new Task(i);
            executor.execute(task);
        }

        // 关闭线程池
        executor.shutdown();
    }

    static class Task implements Runnable {
        private int taskId;

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

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

2.2. `CachedThreadPool`（可缓存线程池）

CachedThreadPool 根据需求创建新线程，如果有可用的空闲线程，则重用；没有可用线程则创建新线程。
适合处理大量短时间任务，不需要固定的线程数。

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

public class CachedThreadPoolExample {

    public static void main(String[] args) {
        // 创建一个可缓存的线程池
        ExecutorService executor = Executors.newCachedThreadPool();

        // 提交任务给线程池执行
        for (int i = 0; i < 10; i++) {
            Runnable task = new Task(i);
            executor.execute(task);
        }

        // 关闭线程池
        executor.shutdown();
    }

    static class Task implements Runnable {
        private int taskId;

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

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

2.3. `SingleThreadExecutor`（单线程线程池）

SingleThreadExecutor 创建一个单线程的线程池，只有一个工作线程执行任务。
适合顺序执行任务的场景，保证任务按提交的顺序依次执行。

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

public class SingleThreadExecutorExample {

    public static void main(String[] args) {
        // 创建一个单线程的线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // 提交任务给线程池执行
        for (int i = 0; i < 5; i++) {
            Runnable task = new Task(i);
            executor.execute(task);
        }

        // 关闭线程池
        executor.shutdown();
    }

    static class Task implements Runnable {
        private int taskId;

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

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

2.4. `ScheduledThreadPool`（定时任务线程池）

ScheduledThreadPool 创建一个定时任务的线程池，用于执行定时任务。
可以按指定的时间间隔执行任务。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {

    public static void main(String[] args) {
        // 创建一个定时任务的线程池，大小为3
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(3);

        // 延迟1秒后执行任务，并每隔2秒执行一次
        executor.scheduleAtFixedRate(new Task(), 1, 2, TimeUnit.SECONDS);
    }

    static class Task implements Runnable {
        @Override
        public void run() {
            System.out.println("Task is being executed by " + Thread.currentThread().getName());
        }
    }
}

2.5. 线程池的工作原理

任务提交： 当有任务需要执行时，可以通过线程池的execute()或submit()等方法提交任务给线程池。
任务队列： 线程池会维护一个任务队列（如BlockingQueue），用于存放提交的任务。待执行的任务将在队列中排队等待。
线程执行： 线程池中的线程会从任务队列中获取任务进行执行。如果线程池中有空闲线程，它会立即执行队列中的任务；如果没有空闲线程，新任务可能会被放入队列中等待执行，或者创建新线程执行任务（取决于线程池类型）。
线程复用： 线程池会重复利用已创建的线程来执行多个任务，而不是为每个任务都创建新的线程。这样可以减少线程创建和销毁的开销，提高性能和资源利用率。
线程管理： 线程池负责管理线程的生命周期，包括线程的创建、启动、执行、暂停、恢复、终止等操作。并根据需要动态调整线程数量，确保线程池中的线程数量不超出设定的范围。

通过以上机制，线程池可以控制线程数量、管理任务执行顺序、减少线程创建销毁的开销、避免线程过多占用资源，满足不同场景的并发需求。

3. 线程池参数详解

corePoolSize：核心线程数，线程池的基本大小，表示线程池中始终保持的线程数量。即使这些线程处于空闲状态，也不会被销毁。
maximumPoolSize：最大线程数，表示线程池中允许的最大线程数量。当队列满了且当前线程数小于最大线程数时，会创建新线程执行任务。
keepAliveTime：线程空闲时间，即当线程数超过核心线程数且处于空闲状态时，这些线程在空闲超过一定时间后会被销毁，直到线程数不超过核心线程数为止。这个时间间隔通过 TimeUnit 类型的参数指定。
workQueue：任务队列，是用于保存等待执行任务的队列，当线程池中的线程数达到 corePoolSize 时，新任务会被放入到工作队列中等待执行。内部通常使用LinkedBlockingQueue、ArrayBlockingQueue 等队列来实现。
ThreadFactory：线程工厂，是 Java 线程池框架中的一个接口，用于创建新的线程对象。可以自定义线程的创建过程，为线程指定名称、设置优先级、定义线程组等。
RejectedExecutionHandler：拒绝策略，定义了当线程池已满并且工作队列也满了时，如何拒绝新任务的策略。常见的策略有：AbortPolicy（默认策略，直接抛出异常）、CallerRunsPolicy（让调用线程执行任务）、DiscardPolicy（丢弃任务）、DiscardOldestPolicy（丢弃队列头部的任务）。

下面看一下线程池参数的代码示例

import java.util.concurrent.*;

public class ThreadPoolParametersExample {

    public static void main(String[] args) {
        int corePoolSize = 5;
        int maxPoolSize = 10;
        long keepAliveTime = 60;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(100);
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();

        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maxPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                handler);

        // 提交任务给线程池执行
        for (int i = 0; i < 20; i++) {
            Runnable task = new Task(i);
            executor.execute(task);
        }

        // 关闭线程池
        executor.shutdown();
    }

    static class Task implements Runnable {
        private int taskId;

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

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

通过设置这些参数，可以根据不同的需求配置线程池，调整线程池的并发性能、资源使用、任务处理能力等方面。

4. 线程池参数实战演示

下面的代码，展示了不同参数值对线程池行为的影响

import java.util.concurrent.*;

public class ThreadPoolParametersImpact {

    public static void main(String[] args) {
        // 不同参数值的影响
        int corePoolSize = 2; // 核心线程数
        int maxPoolSize = 4; // 最大线程数
        long keepAliveTime = 30; // 线程空闲时间（单位：秒）
        int queueCapacity = 2; // 队列容量

        // 不同类型的工作队列：ArrayBlockingQueue 或 LinkedBlockingQueue
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(queueCapacity);
        // BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();

        // 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maxPoolSize,
                keepAliveTime,
                TimeUnit.SECONDS,
                workQueue);

        // 提交任务给线程池执行
        for (int i = 0; i < 8; i++) {
            Runnable task = new Task(i);
            executor.execute(task);
        }

        // 关闭线程池
        executor.shutdown();
    }

    static class Task implements Runnable {
        private int taskId;

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

        @Override
        public void run() {
            System.out.println("Task ID : " + taskId + " is being executed by " + Thread.currentThread().getName());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

可以试着修改 corePoolSize、maxPoolSize、keepAliveTime、queueCapacity 以及工作队列的类型（ArrayBlockingQueue 或 LinkedBlockingQueue），观察不同参数值对线程池行为的影响：

corePoolSize 和 maxPoolSize 的变化如何影响线程池的创建和销毁；
keepAliveTime 对空闲线程的存活时间影响；
工作队列容量的大小对任务的排队等待影响；
不同类型的工作队列对于拒绝策略和任务的处理方式的不同影响。

自定义线程工厂

import java.util.concurrent.*;

public class CustomThreadFactoryExample {

    public static void main(String[] args) {
        // 创建一个自定义的线程工厂
        ThreadFactory customThreadFactory = new CustomThreadFactory();

        // 使用自定义线程工厂创建线程池
        ExecutorService executor = Executors.newFixedThreadPool(5, customThreadFactory);

        // 提交任务
        executor.submit(() -> {
            System.out.println("Task executed by a custom thread from custom thread factory.");
        });

        // 关闭线程池
        executor.shutdown();
    }
}

// 自定义线程工厂类
class CustomThreadFactory implements ThreadFactory {
    private final String threadNamePrefix = "CustomThread-"; // 自定义线程名称前缀
    private int threadCount = 1;

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r, threadNamePrefix + threadCount);
        threadCount++;
        return t;
    }
}

5. 使用注意事项

合适的线程池大小： 根据系统负载和可用资源设置合适的核心线程数和最大线程数，不要盲目设置过高或过低。
选择合适的队列类型： 根据任务性质选择合适的工作队列类型（如 LinkedBlockingQueue 或 ArrayBlockingQueue），控制任务的等待与执行速度。
处理异常和错误： 在任务执行过程中，注意捕获和处理异常，避免因单个任务异常而影响线程池中其他任务的执行。
定期监控和调优： 监控线程池状态，观察线程池中线程数量、队列任务数等情况，根据监控结果动态调整线程池参数。
避免死锁和饥饿： 注意任务执行过程中的资源竞争问题，避免死锁和饥饿现象。
选择合适的拒绝策略： 当线程池已满或无法处理新任务时，合理选择拒绝策略（如 AbortPolicy、CallerRunsPolicy 等）处理未接受的任务。
优雅关闭线程池： 在应用程序结束时，需要优雅地关闭线程池，避免任务被丢弃或未执行完成。
避免线程泄漏： 确保任务执行完成后，释放资源，避免线程泄漏导致资源浪费。
线程安全性考虑： 在多线程环境中，保证共享资源的线程安全性，避免数据竞争和并发问题。
合理使用线程池 API： 使用线程池提供的 API 方法时，需仔细了解其功能和使用场景，避免误用导致问题。