1、线程池的使用场景

线程池在多线程编程中被广泛应用，适用于许多不同的场景。以下是一些常见的线程池使用场景：

并发任务处理：线程池可以用于处理并发的任务，例如处理请求、批量处理数据、并行计算等。通过线程池，可以管理和复用线程，提高任务的执行效率。

异步任务执行：线程池可以用于执行异步任务，将任务提交给线程池后，可以立即返回并继续执行后续代码，不必等待任务完成。适用于需要在后台执行耗时任务，同时不阻塞主线程的场景。

定时任务调度：线程池提供了定时任务执行的功能，可以周期性地执行任务或在指定的时间点执行任务。适用于需要按计划执行任务的场景，例如定时任务、定时检查等。

资源池管理：线程池可以用于管理资源池，例如数据库连接池、线程池等。通过线程池，可以复用和管理资源，提高资源利用率，同时控制资源的并发访问。

并行计算：线程池可以用于并行计算，将计算任务分解为多个子任务，分配给线程池中的线程并行执行，加速计算过程。适用于需要高性能并行计算的场景，如数据处理、图像处理等。

长时间运行的任务：线程池适用于长时间运行的任务，可以控制线程的生命周期，避免频繁创建和销毁线程的开销，提高系统的稳定性和性能。

无论是 Web 服务器、桌面应用程序还是大规模分布式系统，线程池都可以提供更好的性能、可扩展性和资源管理。在选择线程池时，应根据具体的应用需求和系统特点进行评估，并根据性能要求、并发量、资源限制等因素进行合适的调优和配置。

2、线程池概述

在使用多线程时候，都会考虑创建线程池进行线程复用。

Java线程池是一种用于管理和重用线程的机制。它通过维护一组线程，并在需要时分配这些线程来执行任务，从而提高程序的性能和效率。

在Java中，线程池由java.util.concurrent.ExecutorService接口表示。ExecutorService提供了一组方法，用于提交任务并管理线程池的行为。常见的实现类是ThreadPoolExecutor。

要创建一个线程池，可以使用Executors类中的静态工厂方法。以下是创建线程池的示例代码：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池，最多同时执行3个任务
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 提交任务给线程池
        executor.submit(new MyTask("Task 1"));
        executor.submit(new MyTask("Task 2"));
        executor.submit(new MyTask("Task 3"));

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

    static class MyTask implements Runnable {
        private String name;

        public MyTask(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            System.out.println("Executing " + name + " on thread " + Thread.currentThread().getName());
            // 执行具体的任务逻辑
        }
    }
}

在上面的示例中，我们创建了一个固定大小的线程池，最多同时执行3个任务。然后，我们使用executor.submit()方法提交三个任务给线程池。每个任务都是一个Runnable对象，其中定义了具体的任务逻辑。线程池会自动从池中的线程中选择一个可用的线程来执行任务。

注意，在使用完线程池后，我们调用了executor.shutdown()方法来关闭线程池。这会等待所有已提交的任务执行完毕，并停止接受新的任务。

线程池的好处包括提高性能、减少线程创建和销毁的开销、控制线程的最大并发数等。使用线程池可以更好地管理和利用系统的资源，避免线程过多导致系统负载过重的问题。

如果有更多的任务提交给线程池，但当前没有可用的线程，线程池会创建新的线程来执行这些任务。然而，如果线程池的线程数量无限增长，并且任务提交的速度过快，就可能导致线程堆积，最终耗尽系统资源，包括内存，导致 OutOfMemoryError (OOM) 错误。

为了避免这种情况，线程池通常会设置一个最大线程数来限制线程池内的线程数量。当线程池已经达到最大线程数，并且所有线程都正在执行任务时，新的任务可能会被放置在队列中等待执行。如果队列也已满，那么根据线程池的配置策略，可能会拒绝执行该任务。

合理设置线程池的参数涉及到平衡系统负载和资源利用的考量。下面是一些关于如何设置线程池参数的一般指导原则：

核心线程数（Core Pool Size）：核心线程数是线程池中保持活动状态的线程数量。这些线程会一直存在，即使它们处于空闲状态。核心线程数的选择应该基于系统的负载特性、可用的处理器核心数和对响应时间的需求。通常情况下，可以根据系统的处理能力和并发请求量来设置核心线程数。

最大线程数（Maximum Pool Size）：最大线程数是线程池允许的最大线程数量。当核心线程数已满且任务队列也已满时，线程池会创建新的线程来处理任务，直到达到最大线程数。最大线程数的设置应该根据系统资源的限制和负载情况进行调整。过高的最大线程数可能导致线程堆积和资源耗尽，而过低的最大线程数可能导致任务被拒绝执行。一般建议设置最大线程数不超过系统可用的处理器核心数。

队列容量（Blocking Queue Capacity）：任务队列用于存储等待执行的任务。当线程池的线程数已达到核心线程数，并且所有线程都在执行任务时，新的任务会被放置在队列中等待执行。队列容量的选择应考虑任务的数量、处理速度和系统负载情况。如果任务数量大于队列容量，可能导致任务被拒绝执行。常见的队列实现包括有界队列（如ArrayBlockingQueue）和无界队列（如LinkedBlockingQueue）。有界队列可以控制线程池的大小，而无界队列可以避免任务被拒绝执行。

拒绝策略（Rejected Execution Policy）：当线程池和队列都已满时，新提交的任务可能会被拒绝执行。拒绝策略定义了线程池如何处理这些被拒绝的任务。根据实际需求选择合适的拒绝策略。常见的拒绝策略包括抛出异常（AbortPolicy）、在提交任务的线程中执行任务（CallerRunsPolicy）、丢弃任务（DiscardPolicy）和丢弃队列中最早的任务（DiscardOldestPolicy）。

合理设置线程池的参数需要综合考虑系统负载、任务特性和系统资源。通过监控和性能测试，可以根据实际情况进行调整

Java线程池提供了不同的策略来处理任务的提交和线程的创建，例如：

1、ThreadPoolExecutor.AbortPolicy（默认策略）：当线程池和队列都已满时，新提交的任务将抛出RejectedExecutionException异常，拒绝执行。
2、ThreadPoolExecutor.CallerRunsPolicy：当线程池和队列都已满时，新提交的任务由提交该任务的线程来执行，即主线程执行任务。
3、ThreadPoolExecutor.DiscardPolicy：当线程池和队列都已满时，新提交的任务将被丢弃，不会抛出异常，也不会执行该任务。
4、ThreadPoolExecutor.DiscardOldestPolicy：当线程池和队列都已满时，尝试将最早提交的任务从队列中删除，为新提交的任务腾出空间。
为了避免线程池的线程堆积，你可以根据实际情况合理设置线程池的参数，包括核心线程数、最大线程数和队列容量，以及合适的拒绝策略。这样可以控制线程的数量，平衡系统的负载，避免资源耗尽和性能下降。

3、自定义线程池

对于 Executors.newFixedThreadPool(int nThreads) 方法创建的固定大小线程池，其默认的拒绝策略是无法修改的。该方法内部实际上是调用了 ThreadPoolExecutor 的构造方法，但将拒绝策略硬编码为 ThreadPoolExecutor.AbortPolicy，没有提供参数用于自定义。

如果你需要自定义拒绝策略，可以直接使用 ThreadPoolExecutor 的构造方法来创建线程池，并传入自定义的拒绝策略对象。例如：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        int corePoolSize = 100;
        int maxPoolSize = 200;
        int queueCapacity = 100;

        // 创建线程池，并指定自定义的拒绝策略
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maxPoolSize,
                0L,
                TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(queueCapacity),
                new MyRejectedExecutionHandler() // 自定义的拒绝策略
        );

        // 提交任务给线程池
        for (int i = 0; i < 1000; i++) {
            executor.submit(new MyTask(i));
        }

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

    static class MyTask implements Runnable {
        private int taskId;

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

        @Override
        public void run() {
            System.out.println("Executing task " + taskId + " on thread " + Thread.currentThread().getName());
            // 执行具体的任务逻辑
        }
    }

    static class MyRejectedExecutionHandler implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            // 自定义的拒绝策略逻辑
            System.out.println("Task rejected. Do something here.");
        }
    }
}

在这个示例中，我们创建了一个 ThreadPoolExecutor 对象，并通过构造方法传入自定义的拒绝策略对象 MyRejectedExecutionHandler。你可以根据具体需求实现自己的拒绝策略逻辑。

4、线程池的选用

选择适当的线程池类型要根据你的业务需求和应用场景进行评估。以下是一些常见的线程池类型及其适用场景的示例：

**FixedThreadPool**（固定大小线程池）：
适用于任务数固定且相对较小的场景。
可以控制线程数，避免线程过多导致资源消耗过大。
适合执行长时间运行的任务。

**CachedThreadPool**（可缓存线程池）：
适用于任务数较多且执行时间较短的场景。
自动根据任务负载情况调整线程数，可以动态创建和回收线程。
适合短期的异步任务执行。

**SingleThreadExecutor**（单线程线程池）：
适用于需要保证任务按顺序执行、只有一个线程执行的场景。
适合串行执行的任务或需要保持任务执行顺序的场景。

**ScheduledThreadPool**（定时任务线程池）：
适用于需要按照计划执行任务的场景，例如定时任务、周期性任务等。
可以指定任务的执行时间和执行频率。
根据你的业务需求，你需要考虑以下因素来选择合适的线程池：

任务类型和数量：根据任务的特性，选择适当的线程池类型，如长时间运行任务、短期异步任务、定时任务等。
并发量：考虑同时执行任务的并发量，决定线程池的大小。
资源限制：考虑系统资源的限制，避免创建过多的线程导致资源耗尽。
任务优先级和顺序：某些线程池类型可以保证任务按顺序执行，适用于需要任务有序性的场景。
错误处理和拒绝策略：根据业务需求，选择合适的拒绝策略来处理无法执行的任务。
在实际应用中，你可能需要进行基准测试和性能评估，根据系统的负载和性能要求来调整线程池参数，以达到最佳的性能和资源利用率。