深度思考线程池面经

推荐

1 线程池详解（ThreadPoolExecutor）
2 面试必问的线程池，你懂了吗？

1 系统设计类题目

1.1 实现一个线程池，效果是这样的：当流量大的时候，线程数要多一点，当流量小的时候，缩的小一些，如果说线程数过多，线程池又不要炸掉，然后客户端可以阻塞

1 首先需要一个有界队列，同时设置一个corePoolSize和一个maxPoolSize参数，分别表示核心线程数以及支持的最大线程数，corePoolSize设置为OS支持的核心线程数+1，根据内存允许的情况设置maxPoolSize参数；另外会为每一个非核心线程设置一个超时时间，当执行完任务后的一段时间没有被分配新任务就自我注销；

2 主线程一般负责将任务分发给线程池中的线程或者添加任务到阻塞队列，同时我还给主线程一个任务那就是每隔一段时间监测当前的流量情况，如果当前的maxPoolSize设置的比较大，但是发现流量在明显降低，则每次都会减少maxPoolSize的值；如果发现当前的流量比较小，但是流量越来越大，则会每次加大maxPoolSize，直到maxPoolSize达到一个系统内存的临界值，这里的检测机制是不断判断当前的等待队列是否已满，并且总线程数是否快要到达maxPoolSize，如果都是则扩容；如果等待队列都没满甚至为空，则可以慢慢减少maxPoolSize。

3 当maxPoolSize加大到系统的临界值并且阻塞队列已经满时，不会执行拒绝策略，主线程不再分配任务给本地的线程池，而是先放入到消息队列中，等待本地的队列中的任务执行了大部分时才将其从消息队列中预取一部分到本地队列。

1.1.1 gpt4对这个方案的评估

您的方案基本上涵盖了线程池的动态调整、任务缓冲以及过载保护的一些核心思路，是一个不错的起点。以下是对您方案的一些补充和建议：

1. 核心线程数设置：

   • 将corePoolSize设置为OS支持的核心线程数+1是一个合理的默认选择。但请记住，核心线程数的最佳设置可能会因应用场景而异。具体的最佳设置可能需要基于负载测试来确定。

2. 动态调整maxPoolSize：

   • 动态地调整maxPoolSize是一个有趣的想法。但请注意，Java的ThreadPoolExecutor默认并不支持动态调整maxPoolSize。您可能需要自定义线程池来实现这个功能。
   • 对于检测机制，您可能需要保证它的粒度不要太细，以避免频繁的调整，这样可能会影响性能。

3. 使用消息队列：

   • 当本地队列满时，将任务放入消息队列是一个不错的备选方案，尤其在微服务环境中。这也为跨节点负载均衡提供了一种机制。
   • 请注意，这种方式会引入额外的延迟和系统复杂性。您需要确保消息队列的可靠性和低延迟。

4. 客户端阻塞：

   • 您提到"客户端可以阻塞"，这意味着当线程池和队列都满时，您想让客户端等待，直到有资源可用。这可以通过使用CyclicBarrier或Semaphore来实现，但要小心，因为这可能会导致客户端超时或其他潜在问题。

5. 线程池饱和策略：

   • 考虑实现自定义的拒绝策略。例如，您可以将任务放入备份存储，如消息队列或数据库，然后在资源可用时再次尝试。

6. 监控与告警：

   • 考虑添加监控和告警功能，当线程池接近饱和或达到某些阈值时，可以发送通知。这有助于系统管理员及时介入并采取必要的措施。

总之，您的方案是一个很好的开始，但要确保在实际环境中进行充分测试和验证。

1.1.3 完善后的版本

主要是动态改变maxPoolSize的粒度上的区别，其他的几乎没变：

1 首先需要一个有界队列，同时设置一个corePoolSize和一个maxPoolSize参数，分别表示核心线程数以及支持的最大线程数，corePoolSize设置为OS支持的核心线程数+1，根据内存允许的情况设置maxPoolSize参数；另外会为每一个非核心线程设置一个超时时间，当执行完任务后的一段时间没有被分配新任务就自我注销；

2 主线程一般负责将任务分发给线程池中的线程或者添加任务到阻塞队列，同时我还给主线程一个任务那就是每隔一段时间监测当前的流量情况，如果当前的maxPoolSize设置的比较大，但是发现流量在明显降低，则粗粒度的减少maxPoolSize的值；如果发现当前的流量比较小，但是流量越来越大，则会一次性粗粒度的加大maxPoolSize，直到maxPoolSize达到一个系统内存的临界值，这里的检测机制是不断判断当前的等待队列是否已满，并且总线程数是否快要到达maxPoolSize，如果都是则扩容；如果等待队列都没满甚至为空，则可以慢慢减少maxPoolSize。

3 当maxPoolSize加大到系统的临界值并且阻塞队列已经满时，不会执行拒绝策略，主线程不再分配任务给本地的线程池，而是先放入到消息队列中，等待本地的队列中的任务执行了大部分时才将其从消息队列中预取一部分到本地队列。

1.2 面对这里的大流量情况，对于本地内存放不下的任务是不是可以放入到远程服务器的队列中，等待有空闲线程时再去取，但是对于消费者不返回失败，这样设计可以吗？

当面对大流量，本地内存不足以存放待处理的任务时，使用远程服务器的队列（如分布式队列如Kafka, RabbitMQ等）确实是一个可行的策略。这样的设计可以有以下优势：

• 缓解流量压力：即使本地线程池和任务队列已满，也能保证任务不会被直接丢弃。
• 高可用与伸缩性：分布式队列一般设计为高可用，能够水平扩展，以满足大量的写入请求。
• 任务持久化：即使应用或服务器崩溃，已存入远程队列的任务不会丢失。

然而，这种方法也有挑战：

• 网络延迟：与远程队列的通信将引入额外的网络延迟。
• 复杂性增加：引入远程队列需要更复杂的部署和维护策略。
• 成本：增加额外的服务器和网络带宽成本。
• 对于消费者不返回失败，这种设计方式可以增强用户体验和系统的健壮性，但你需要确保系统可以在后续有效地处理这些任务，避免长时间的延迟或其他问题。

1.3 一般一个服务通常是集群部署，线程中的队列已满，并且线程数已达到阈值，这个时候我将收到的新任务发给其他的微服务实例可以吗？

当一个服务（微服务）实例的线程池队列已满，并且线程数达到上限时，将新任务转发给同类型的其他微服务实例是一种可能的策略。这样的策略也被称为任务或请求重定向。不过这种策略在实践中应当谨慎使用，并确保考虑以下几点：

1. 负载均衡策略：负载均衡器（例如Nginx, HAProxy, AWS ELB等）通常已经实现了请求分发的策略。在应用层再次实现重定向可能导致某些问题。例如，如果所有实例都转发请求，可能导致循环重定向的问题。

2. 网络开销：请求重定向将导致额外的网络延迟。这可能会影响系统的总体性能，尤其是在高请求率的场景中。

3. 同一集群的压力：如果所有实例都面临类似的压力，即使重定向请求到另一个实例，那么问题仍然可能存在。所以在使用这种策略之前，需要确保其他实例确实有足够的资源来处理重定向的请求。

4. 错误和故障传播：过多地重定向请求可能导致错误或故障的快速传播，从而影响整个服务集群的健康状态。

5. 跟踪和监控：为确保此策略的有效性，需要对转发的请求进行跟踪和监控，以及设置合适的告警。如果重定向的请求太多，可能表明系统存在其他问题，如资源瓶颈、配置问题等。

6. 备选策略：考虑其他备选方案，如扩容实例、优化线程池策略、使用回压机制、异步处理等。

总之，尽管任务或请求重定向是一种可行的策略，但实现和维护它可能相对复杂，并可能引入新的风险。在使用之前，务必进行深入的评估和测试。

1.4 一般一个服务通常是集群部署，线程中的队列已满，并且线程数已达到阈值，因为一般客户端发送请求会采取负载均衡策略，所以可能这个集群中的实例都处于忙碌状态，这个时候面新来的请求，我做出告警，让管理者迅速部署或者自动部署新的服务实例，然后服务提供者执行特殊的拒绝策略，告知消费者重定向到刚刚新增的服务实例，这样可以吗？

这种策略涉及到多个层面的操作和通讯。在某些情境中，确实可以考虑这种策略。以下是对这种策略的评估：

1. 自动扩容：许多现代云平台（如AWS、Google Cloud、Azure等）都支持基于特定指标（如CPU利用率、网络I/O、队列长度等）的自动扩容。如果您已经在这些平台上部署了服务，那么您可以配置自动扩容来迅速响应流量增长。

2. 拒绝策略：服务提供者可以实施特殊的拒绝策略，这确实是一种可能的解决方案。但这种策略的效果取决于客户端如何处理这种重定向通知。此外，您需要保证新的服务实例已经准备好并且可以接受这些重定向的请求。

3. 服务发现和注册：为了实现动态重定向到新的服务实例，您需要一个动态的服务发现和注册机制，如Consul、Eureka或其他服务注册中心。这样，新部署的服务实例可以被快速发现并加入到负载均衡器中。

4. 告警：确实，当系统资源达到临界值时，发送告警是很有必要的。这既可以提醒系统管理员采取措施，也可以触发自动响应机制。

5. 网络延迟和额外的开销：请注意，重定向请求会引入额外的网络延迟，而且需要客户端执行额外的操作。这可能会对系统的整体响应时间产生影响。

6. 流量预测和资源预留：虽然自动扩容和动态重定向是有效的应对策略，但在某些情况下，预先估计流量并据此预留资源可能更为高效。

7. 平滑的拒绝策略：考虑采用回退机制，如提供降级服务、缓存结果等，这可以提供更平滑的用户体验，即使在高流量情况下。

总体上说，这是一个有前景的策略，但在实施之前需要考虑多种因素。建议在非生产环境中进行深入的测试，确保策略的有效性并优化相关的配置。

1.5 一般一个服务通常是集群部署，线程中的队列已满，并且线程数已达到阈值时，能不能将任务存储到磁盘，等到队列不满时候再从磁盘中取出任务放入队列中？

将任务存储到磁盘是一种可能的策略，称为“磁盘交换”或“磁盘备份”。在某些场景中，这种策略可能有效，但也有一些明显的缺点和挑战：

1. I/O 性能：磁盘I/O通常比内存I/O慢得多。频繁地将任务写入磁盘和从磁盘读取任务可能导致明显的性能下降。

2. 数据持久化：一旦任务被写入到磁盘，它们会变得更为持久。如果服务器意外关机或重新启动，这些任务仍然存在，可以在重新启动后继续处理。这可能是一个优势，但也需要管理和跟踪这些存储在磁盘上的任务。

3. 磁盘空间：如果任务积压太多，可能会用尽服务器的磁盘空间，从而导致其他问题。

4. 复杂性：实施这种策略需要更复杂的编程和资源管理策略，包括任务序列化、磁盘管理和错误处理。

5. 数据一致性和完整性：磁盘故障、软件错误或其他问题可能导致存储在磁盘上的任务数据丢失或损坏。

6. 延迟：将任务移动到磁盘并在后续从磁盘中恢复，会增加处理任务的延迟。

基于上述因素，虽然将任务存储到磁盘是一种策略，但在考虑这种方法之前需要深入思考。通常更常见的策略是使用像RabbitMQ、Kafka、Redis等外部消息队列来缓冲任务，这些系统已经针对高吞吐量和数据持久化进行了优化。当内部队列满时，可以将任务放入外部消息队列，并在有空间时从外部队列中取出任务进行处理。这种策略可以有效地处理大量的任务积压，同时提供更好的扩展性和容错能力。

2 疑问

2.1 这里的“只有当线程池是无界的或者可以拒绝任务时，该队列才有实际价值”，为什么这么说

SynchronousQueue是一种特殊的队列，它不保留任务，而是直接将任务移交给工作线程。这种队列适合于执行大量生命周期非常短的异步任务。

当说“只有当线程池是无界的或者可以拒绝任务时，该队列才有实际价值”是因为：

无界线程池：SynchronousQueue没有存储任务的能力，所以每次添加任务都需要有一个可用的线程。如果线程池是无界的，那么每次添加任务时，都可以创建一个新的线程来处理这个任务。

拒绝策略：如果线程池已经达到其最大值并且所有线程都在忙，使用SynchronousQueue的话将无法存储更多的任务。这时，线程池必须有策略来拒绝新的任务，否则将会出现资源耗尽的问题。

使用SynchronousQueue的场景，如Executors.newCachedThreadPool，就是基于这样的原则：它不保留任何待处理的任务，但会根据需要创建新的线程，直到达到系统的最大限制。当线程空闲一定时间后，它会被终止和回收，所以这种线程池适用于执行大量生命周期非常短的异步任务。

2.2 线程池的maxPoolSize参数是动态可变的吗

在Java的java.util.concurrent.ThreadPoolExecutor中，maxPoolSize参数在初始化线程池时被设置，但在创建后也可以动态地进行修改。

你可以使用ThreadPoolExecutor的setMaxPoolSize(int maximumPoolSize)方法来在运行时动态地修改maxPoolSize。例如：

ThreadPoolExecutor executor = new ThreadPoolExecutor(...);
executor.setMaxPoolSize(newMaxPoolSize);

但是有几点需要注意：

1. 增加maxPoolSize：如果你在运行时增加了maxPoolSize，并且当前的线程数低于新设置的maxPoolSize，线程池可能会因为队列中等待的任务而创建新的线程，直到线程数达到新的maxPoolSize或队列为空。

2. 减少maxPoolSize：如果你减少了maxPoolSize，并且当前的线程数超过了新设置的maxPoolSize，多余的线程不会立即终止。只有当它们处于空闲状态并且超过了keepAliveTime时，它们才会被终止。这意味着，在某些情况下，实际的线程数可能会暂时超过maxPoolSize。

3. 并发问题：如果你在多线程环境中动态地修改maxPoolSize，需要确保这种修改不会导致竞争条件或其他线程安全问题。

总的来说，虽然可以动态地修改maxPoolSize，但在做此类修改时需要谨慎，并确保了解其行为和可能的后果。

2.3 根据以下引用，为什么当等待队列满了，才开始创建非核心线程？

从图中可以看出，当提交一个新任务到线程池时，线程池的处理流程如下。
1 默认情况下，创建完线程池后并不会立即创建线程,
而是等到有任务提交时才会创建线程来进行处理。（除非调用prestartCoreThread或prestartAllCoreThreads方法）
2 当线程数小于核心线程数时，每提交一个任务就创建一个线程来执行，即使当前有线程处于空闲状态，直到当前线程数达到核心线程数。
3 当前线程数达到核心线程数时，如果这个时候还提交任务，这些任务会被放到工作队列里，等到线程处理完了手头的任务后，会来工作队列中取任务处理。
4 当前线程数达到核心线程数并且工作队列也满了，如果这个时候还提交任务，则会继续创建线程来处理，直到线程数达到最大线程数。
5 当前线程数达到最大线程数并且队列也满了，如果这个时候还提交任务，则会触发饱和策略。
6 如果某个线程的控线时间超过了keepAliveTime，那么将被标记为可回收的，并且当前线程池的当前大小超过了核心线程数时，这个线程将被终止。

答：这种设计背后的思路是效率和资源的平衡。

1. 节约资源: 核心线程通常是常驻内存的，这意味着它们不会因为空闲而被回收。为了避免浪费资源，线程池的设计者决定首先使用核心线程来处理任务，直到它们都忙碌为止。这种策略确保了线程池始终使用最小的线程数来处理请求，从而最大化了每个线程的使用。

2. 工作队列作为缓冲: 当核心线程都在忙碌时，新任务会被放入工作队列。这个队列充当了一个缓冲器，确保在短时间内的请求高峰期间，不会立即创建大量的新线程。这有助于系统吞吐量，并减少了线程创建和销毁的开销。

3. 应对持续高负载: 如果工作队列满了，说明现有的核心线程和队列的容量都不能应对当前的请求负载。这时，线程池开始创建非核心线程来处理新的请求。这确保了即使在高负载情况下，请求仍然可以得到处理，而不是被拒绝。

4. 保护系统: 设计中设置了一个最大线程数，其目的是为了确保在极端的情况下，线程池不会创建过多的线程，从而耗尽系统资源。

综上所述，这种策略是为了在高效使用资源和应对高负载之间找到一个平衡。线程的创建和销毁都是有开销的，因此，当有核心线程和工作队列这样的缓冲机制时，可以确保线程池在大多数情况下都能高效地运行。只有在负载真正高到需要更多线程来处理的时候，才会创建额外的线程。

2.4 如果最大线程数达到了阈值，但是等待队列没有，此时新来的任务是放入队列中嘛还是创建新的线程

如果线程池中的当前线程数量已经达到maxPoolSize（即最大线程数），而新的任务又提交到线程池，此时的处理策略是这样的：

1. 如果工作队列尚未满，新的任务将被放入队列中等待被执行。
2. 如果工作队列已满，那么线程池会根据其拒绝策略（RejectedExecutionHandler）来处理这个新提交的任务。常见的拒绝策略包括抛出异常、丢弃任务、丢弃队列中的一个旧任务来为新任务腾出空间等。

所以答案是：如果最大线程数已经达到阈值，新来的任务首先尝试放入等待队列。只有当队列也满了的情况下，才会触发拒绝策略。

2.5 如果最大线程数和等待队列都没达到阈值呢

总的来说，当最大线程数和等待队列都没达到阈值时，新提交的任务首先会被尝试分配给一个核心线程。如果核心线程数量已满，那么新任务将会被放入等待队列。