线程池 ThreadPoolExecutor 详细讲解

线程池有哪些优势？

线程池具有以下几个优势：

1. 降低资源消耗：线程池可以重复利用线程，避免了频繁创建和销毁线程的开销。线程的创建和销毁是比较昂贵的操作，使用线程池可以减少这种开销，提高资源利用率。
2. 提高响应速度：线程池可以预先创建一定数量的线程，当有任务到达时，可以立即分配线程进行处理，避免了任务等待线程创建的时间，从而提高了响应速度。
3. 控制并发线程数量：线程池可以限制并发执行的线程数量，防止系统资源被过度占用。通过设置线程池的大小，可以控制同时执行的线程数量，避免线程过多导致系统负载过重，提高系统的稳定性和可靠性。
4. 提供任务队列：线程池通常会使用任务队列来存储等待执行的任务。当线程池中的线程都在执行任务时，新的任务可以被放入队列中等待执行，避免任务丢失或者被拒绝执行。
5. 统一管理和监控：线程池可以统一管理和监控线程的状态和执行情况。通过线程池，可以方便地获取线程池中线程的状态、任务的执行情况以及线程池的运行状况，便于进行监控和调优。

总之，线程池能够提高系统的性能、资源利用率和响应速度，同时还能够提供对线程的统一管理和监控，是多线程编程中常用的一种并发控制机制。

---

---

常见的线程池有哪些？

常见的线程池有以下几种：

1. FixedThreadPool（固定大小线程池）：该线程池包含固定数量的线程，当有新任务提交时，如果线程池中有空闲线程，则立即使用空闲线程执行任务；如果所有线程都在执行任务，则新任务将在队列中等待，直到有空闲线程可用。
2. CachedThreadPool（缓存线程池）：该线程池根据任务的数量动态调整线程的数量。当有新任务提交时，如果有空闲线程可用，则立即使用空闲线程执行任务；如果没有空闲线程，则创建一个新线程。当线程空闲一段时间后，如果没有新任务提交，该线程将被终止并从线程池中移除。
3. SingleThreadExecutor（单线程线程池）：该线程池只包含一个线程，用于顺序执行所有任务。如果该线程在执行任务时出现异常而终止，线程池会创建一个新线程来替代。
4. ScheduledThreadPool（定时任务线程池）：该线程池用于执行定时任务和周期性任务。它可以按照指定的时间间隔执行任务，或者在指定的延迟时间后执行任务。

这些线程池类型在不同的场景下有不同的用途。例如，FixedThreadPool适用于需要控制并发线程数量的场景，CachedThreadPool适用于需要处理大量短期任务的场景，SingleThreadExecutor适用于需要按顺序执行任务的场景，ScheduledThreadPool适用于需要执行定时任务的场景。

---

---

线程池七个重要参数介绍

线程池有几个重要的参数，它们是：

1. 核心线程数（Core Pool Size）：核心线程数是线程池中保持的最小线程数量。在没有任务执行时，核心线程会一直存活。当有新任务提交时，线程池会优先创建核心线程来处理任务。
2. 最大线程数（Maximum Pool Size）：最大线程数是线程池中允许的最大线程数量。当任务数量超过核心线程数，并且任务队列已满时，线程池会创建新的线程来处理任务，直到达到最大线程数。超过最大线程数的任务将会被拒绝执行或采取其他策略处理。
3. 线程存活时间（Keep Alive Time）：线程存活时间指的是当线程池中的线程数量超过核心线程数时，多余的空闲线程在等待新任务到达时保持存活的时间。超过存活时间的空闲线程会被终止并从线程池中移除，以减少资源消耗。
4. 时间单位（Time Unit）：时间单位用于指定核心线程存活时间和任务超时时间的单位，常见的时间单位包括毫秒（Milliseconds）、秒（Seconds）、分钟（Minutes）等。
5. 任务队列（Work Queue）：任务队列用于存储等待执行的任务。当线程池中的线程都在执行任务时，新的任务会被放入任务队列中等待执行。任务队列可以是有界队列或无界队列，有界队列可以控制任务的数量，而无界队列则可以无限制地接收任务。
6. 线程工厂（Thread Factory）：线程工厂用于创建新的线程对象。通过自定义线程工厂，可以对线程进行一些额外的配置，例如设置线程的名称、优先级等。
7. 拒绝策略（Rejected Execution Handler）：当线程池无法接受新的任务时，就会触发拒绝策略。拒绝策略定义了当任务被拒绝时的处理方式，常见的策略包括抛出异常、丢弃任务、丢弃最旧的任务或在调用者线程中执行任务。

这些参数可以根据应用程序的需求进行调整，以平衡线程池的性能和资源消耗。合理地设置这些参数可以提高线程池的效率和响应能力，避免资源浪费和任务丢失。

---

---

如何自定义线程池？

要自定义线程池，可以使用ThreadPoolExecutor类，它是Java提供的一个可扩展的线程池实现。通过使用ThreadPoolExecutor类，可以更灵活地配置线程池的参数和行为。

下面是一个示例代码，演示如何使用ThreadPoolExecutor自定义线程池：

import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.RejectedExecutionHandler;

public class CustomThreadPoolExample {
    public static void main(String[] args) {
        // 创建自定义线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, // 核心线程数
                5, // 最大线程数
                1, // 线程存活时间
                TimeUnit.MINUTES, // 存活时间单位
                new ArrayBlockingQueue<>(10), // 任务队列
                new CustomThreadFactory(), // 线程工厂
                new CustomRejectedExecutionHandler() // 拒绝策略
        );

        // 提交任务给线程池执行
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
                    try {
                        // 模拟任务执行耗时
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("Task " + taskId + " completed");
                }
            });
        }

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

// 自定义线程工厂
class CustomThreadFactory implements ThreadFactory {
    private int counter = 1;

    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName("CustomThread-" + counter++);
        // 设置线程优先级等
        return thread;
    }
}

// 自定义拒绝策略
class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task rejected: " + r.toString());
        // 自定义处理被拒绝的任务，例如记录日志或抛出异常等
    }
}

当你运行上述代码示例时，它将创建一个自定义的线程池并提交10个任务给线程池执行。下面是代码示例的详细解释：

首先，在main方法中，我们创建了一个ThreadPoolExecutor实例executor，并传入以下参数：

• 2：核心线程数，表示线程池中保持活动状态的线程数量。在这个例子中，我们设置核心线程数为2，意味着线程池会始终保持2个活动线程。
• 5：最大线程数，表示线程池允许的最大线程数量。在这个例子中，我们设置最大线程数为5，意味着线程池最多可以创建5个线程来处理任务。
• 1：线程存活时间，表示非核心线程的空闲时间。在这个例子中，我们设置线程存活时间为1分钟。如果一个线程在空闲1分钟后没有任务可执行，它将被终止并从线程池中移除。
• TimeUnit.MINUTES：存活时间单位，表示线程存活时间的单位。在这个例子中，我们将存活时间单位设置为分钟。
• new ArrayBlockingQueue<>(10)：任务队列，表示等待执行的任务队列。在这个例子中，我们使用了一个大小为10的有界阻塞队列作为任务队列。如果线程池中的线程都在处理任务，新提交的任务将被放入任务队列中等待执行。
• new CustomThreadFactory()：线程工厂，用于创建新的线程。在这个例子中，我们使用自定义的线程工厂CustomThreadFactory来创建线程。线程工厂可以用于设置线程的名称、优先级等。
• new CustomRejectedExecutionHandler()：拒绝策略，用于处理无法执行的任务。在这个例子中，我们使用自定义的拒绝策略CustomRejectedExecutionHandler来处理无法执行的任务。当线程池无法接受新的任务时，拒绝策略会被触发。

接下来，我们使用一个循环提交10个任务给线程池执行。每个任务都是一个匿名的Runnable对象，其中包含任务的逻辑。在这个例子中，任务只是简单地打印一条消息，模拟任务执行耗时，并在任务完成后打印另一条消息。

最后，我们调用executor.shutdown()方法关闭线程池。这会停止接受新的任务，并等待已提交的任务执行完成。请注意，调用shutdown()方法后，线程池不会立即关闭，而是等待所有任务执行完成。你可以使用awaitTermination()方法等待线程池完全关闭。

在代码示例的末尾，我们还定义了两个辅助类：CustomThreadFactory和CustomRejectedExecutionHandler。

CustomThreadFactory实现了ThreadFactory接口，用于创建新的线程。在newThread()方法中，我们创建一个新的线程并设置其名称为"CustomThread-"加上一个递增的计数器。你可以在这里进行其他线程属性的设置，如优先级、守护状态等。

CustomRejectedExecutionHandler实现了RejectedExecutionHandler接口，用于处理无法执行的任务。在rejectedExecution()方法中，我们打印一条消息表示任务被拒绝，并抛出一个自定义的异常RejectedTaskException。你可以在这里进行其他处理，如记录日志、通知等。

---

---

拒绝策略有哪些？

线程池的拒绝策略用于处理无法执行的任务，当线程池无法接受新的任务时，会触发拒绝策略。以下是常见的拒绝策略：

1. AbortPolicy（默认）：默认的拒绝策略，当线程池无法接受新的任务时，会抛出RejectedExecutionException异常。
2. CallerRunsPolicy：当线程池无法接受新的任务时，会将任务返回给提交任务的线程来执行。这意味着提交任务的线程将会执行该任务，而不是将任务交给线程池中的其他线程执行。
3. DiscardPolicy：当线程池无法接受新的任务时，会默默地丢弃该任务，不做任何处理。这种策略可能会导致任务丢失，不推荐在生产环境中使用。
4. DiscardOldestPolicy：当线程池无法接受新的任务时，会丢弃最早提交的任务，然后尝试提交新的任务。这种策略可以确保线程池不会被阻塞，但也可能导致一些任务被丢弃。

除了以上四种常见的拒绝策略，你还可以自定义拒绝策略。为此，你需要实现RejectedExecutionHandler接口，并实现其中的rejectedExecution()方法。在该方法中，你可以定义自己的拒绝策略逻辑，如记录日志、通知等。

要使用自定义的拒绝策略，只需在创建线程池时，调用setRejectedExecutionHandler()方法，并传入你的自定义拒绝策略实例。

请注意，选择适当的拒绝策略取决于你的应用场景和需求。需要根据具体情况选择合适的策略来处理无法执行的任务。

---

---

如何自定义拒绝策略？

如果你想在拒绝策略中记录日志并抛出异常，你可以按照以下方式修改CustomRejectedExecutionHandler类：

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task rejected: " + r.toString());
        // 记录日志
        // logger.log("Task rejected: " + r.toString());

        // 抛出自定义异常
        throw new RejectedTaskException("Task rejected: " + r.toString());
    }
}

class RejectedTaskException extends RuntimeException {
    public RejectedTaskException(String message) {
        super(message);
    }
}

在上述代码中，我们修改了CustomRejectedExecutionHandler类的rejectedExecution()方法。首先，我们打印出被拒绝的任务信息，你可以根据需要将其替换为记录日志的逻辑，例如使用日志框架记录日志。

然后，我们抛出了一个自定义的RejectedTaskException异常，并将被拒绝的任务信息作为异常消息传递给它。可以根据需要自定义异常类的继承关系和异常消息。

这样，在任务被拒绝时，会记录日志并抛出异常，你可以根据具体场景来处理该异常。

---

---

最大线程数，核心线程数如何设定？

设置最大线程数和核心线程数需要根据你的应用需求和系统资源来决定。以下是一些一般的指导原则：

• 核心线程数：核心线程数是线程池中保持活动状态的线程数量。当有新任务提交时，线程池会优先创建核心线程来处理任务，直到达到核心线程数。如果任务数量超过核心线程数，任务将被放入任务队列中等待执行。核心线程数的设置应该根据你的应用需求和系统资源来确定。如果你的任务是CPU密集型的，可以根据CPU核心数来设置核心线程数，以充分利用系统资源。如果你的任务是IO密集型的，可以根据IO操作的并发性来设置核心线程数。
• 最大线程数：最大线程数是线程池中允许的最大线程数量，包括核心线程和非核心线程。当任务数量超过核心线程数并且任务队列已满时，线程池会创建非核心线程来处理任务，直到达到最大线程数。如果任务数量继续增加，线程池将采取拒绝策略来处理新任务。最大线程数的设置应该考虑系统资源的限制，避免创建过多的线程导致系统负载过高或资源耗尽。

一般来说，可以根据以下步骤来设置最大线程数和核心线程数：

1. 确定系统的CPU核心数：可以使用Runtime.getRuntime().availableProcessors()方法获取当前系统的CPU核心数。
2. 根据应用类型和任务特性来确定核心线程数：如果任务是CPU密集型的，可以将核心线程数设置为CPU核心数加1或2，以充分利用系统资源。如果任务是IO密集型的，可以根据IO操作的并发性来设置核心线程数。
3. 根据系统资源和负载情况来确定最大线程数：最大线程数的设置应该考虑系统资源的限制，避免创建过多的线程导致系统负载过高或资源耗尽。通常，最大线程数可以设置为核心线程数的两倍或更高，具体取决于你的应用需求和系统资源。

需要注意的是，线程池的性能和效果取决于合适的线程数配置。过少的线程数可能导致任务无法及时处理，而过多的线程数可能导致线程切换开销增加。因此，根据实际情况进行调优是很重要的。可以通过监控线程池的运行情况和系统资源的利用率来进行评估和调整。