Spring Boot提供了默认的线程池来执行异步任务。我们将详细讨论Spring Boot的线程池以及如何配置它。



## Spring Boot默认线程池
默认情况下，Spring Boot使用线程池来执行异步任务。这个线程池是自动配置的，并具有以下默认值：
- 核心线程数：8
- 最大线程数：Integer.MAX_VALUE
- 队列容量：Integer.MAX_VALUE
- 空闲线程存活时间：60秒

默认线程池基于Spring Framework的`ThreadPoolTaskExecutor`。它提供了一种灵活高效的方式来管理线程，以异步方式执行任务。

## 配置默认线程池
要配置Spring Boot的默认线程池，可以使用`application.properties`文件。以下是一些常见的属性配置：
- `spring.task.execution.pool.core-size`：核心线程数（默认值：8）
- `spring.task.execution.pool.max-size`：最大线程数（默认值：Integer.MAX_VALUE）
- `spring.task.execution.pool.queue-capacity`：队列容量（默认值：Integer.MAX_VALUE）
- `spring.task.execution.pool.keep-alive`：空闲线程存活时间（默认值：60秒）
- `spring.task.execution.pool.allow-core-thread-timeout`：是否允许核心线程超时（默认值：false）
- `spring.task.execution.shutdown.await-termination`：是否等待任务在关闭时终止（默认值：false）
- `spring.task.execution.shutdown.await-termination-period`：等待任务在关闭时终止的时间（默认值：空）

还可以使用`spring.task.execution.thread-name-prefix`属性配置线程名称前缀。

要以编程方式配置默认线程池，可以创建一个配置类并使用`@EnableAsync`注解。以下是一个示例：

```java
@Configuration
@EnableAsync
public class ExecutePoolConfig {

    @Value("${spring.task.execution.pool.core-size}")
    private int corePoolSize;

    @Value("${spring.task.execution.pool.max-size}")
    private int maxPoolSize;

    @Value("${spring.task.execution.pool.keep-alive}")
    private int keepAliveSeconds;

    @Value("${spring.task.execution.pool.queue-capacity}")
    private int queueCapacity;
    
    @Value("${spring.task.execution.thread-name-prefix}")
    private String threadNamePrefix;

    // 线程池执行器的Bean定义
    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setQueueCapacity(queueCapacity);
        executor.setThreadNamePrefix(threadNamePrefix);
        executor.initialize();
        return executor;
    }
}
```

## 自定义线程池
如果需要更多对线程池配置的控制，可以创建一个自定义的`ThreadPoolTaskExecutor` bean，并根据需求进行配置。这样可以设置线程优先级、拒绝策略和线程工厂等属性。

## 流程
Spring的ThreadPoolTaskExecutor是Spring框架提供的一个线程池实现类，它是对Java标准库中的ThreadPoolExecutor进行了封装和扩展。ThreadPoolTaskExecutor提供了更多的配置选项和功能，使得线程池的使用更加方便和灵活。

下面是对ThreadPoolTaskExecutor的详细解释：

1. 线程池的配置参数：
   - corePoolSize：核心线程数，线程池中始终保持的活动线程数。
   - maxPoolSize：最大线程数，线程池中允许的最大线程数。
   - queueCapacity：任务队列容量，用于存放等待执行的任务。
   - keepAliveSeconds：非核心线程的存活时间，当线程池中的线程数量超过核心线程数时，空闲线程的存活时间。
   - threadNamePrefix：线程名的前缀，用于区分不同线程的名称。

2. 线程池的执行流程：
   - 当有任务提交到线程池时，首先会检查核心线程数是否已满，如果未满，则创建新的线程来执行任务。
   - 如果核心线程数已满，任务会被放入任务队列中等待执行。
   - 如果任务队列也已满，且线程池中的线程数量未达到最大线程数，则会创建新的线程来执行任务。
   - 如果线程池中的线程数量已达到最大线程数，且任务队列也已满，则根据配置的拒绝策略来处理无法执行的任务。

3. 拒绝策略：
   - ThreadPoolTaskExecutor提供了多种拒绝策略供选择，用于处理无法执行的任务：
     - AbortPolicy：直接抛出RejectedExecutionException异常。
     - CallerRunsPolicy：由调用线程来执行任务。
     - DiscardPolicy：直接丢弃无法执行的任务。
     - DiscardOldestPolicy：丢弃队列中最旧的任务，然后尝试重新执行任务。

4. 使用ThreadPoolTaskExecutor的步骤：
   - 在Spring配置文件中配置ThreadPoolTaskExecutor的相关参数，或者使用注解方式进行配置。
   - 在需要使用线程池的地方，通过@Autowired注入ThreadPoolTaskExecutor实例。
   - 调用ThreadPoolTaskExecutor的execute()方法提交任务到线程池中执行。

以上是对Spring的ThreadPoolTaskExecutor的详细解释。通过配置参数和拒绝策略的灵活性，以及对线程池的管理和监控，ThreadPoolTaskExecutor可以帮助开发者更好地管理和利用线程池，提高应用程序的性能和并发能力。

---
Learn more:
1. [Spring自带的线程池ThreadPoolTaskExecutor - 知乎](https://zhuanlan.zhihu.com/p/346086161)
2. [ThreadPoolTaskExecutor原理、详解及案例 - 幸运的小六子 - 博客园](https://www.cnblogs.com/pansw/p/10639055.html)
3. [ThreadPoolTaskExecutor - 掘金](https://juejin.cn/post/7087583684307959838)

1. [springboot线程池超级详解 - IT界~挑山工 - 博客园](https://www.cnblogs.com/linuxtop/p/16969358.html)
2. [Spring Boot线程池的配置与解释 - 掘金](https://juejin.cn/post/7198039436037701687)
3. [SpringBoot线程池使用详解_springboot操作线程池-CSDN博客](https://blog.csdn.net/qq_37936542/article/details/107162343)

SpringBoot线程池

Java的ThreadPool（线程池）是Java提供的一种用于管理和复用线程的工具。它可以有效地管理线程资源，减少线程创建和销毁的开销，并提高系统的性能和响应速度。

## 线程池的概述
线程池是一个包含多个线程的池子，用于执行任务。当用户提交任务时，线程池会从池中获取一个线程来执行任务。如果任务超过了核心线程数，线程池会将任务放入一个任务队列中进行排队等待执行。线程池的好处在于减少了线程创建和销毁的开销，提高了资源的利用率。



## 为何要使用线程池？
使用线程池有以下几个优点：
1. 降低开销：频繁创建和销毁线程会产生很大的系统开销，而线程池可以重复利用已创建的线程，减少了这种开销。
2. 易复用和管理：线程池将线程统一管理，可以进行复用和管理，例如延时执行、统一命名线程等。
3. 解耦：线程的创建和销毁与任务执行完全分离，方便维护和专注于业务开发。

## 线程池的优势
使用线程池可以带来以下优势：
1. 提高资源的利用性：通过池化可以重复利用已创建的线程，降低了创建和销毁线程的资源开销。
2. 提高线程的管理性：可以统一管理线程的创建、销毁和监控，防止线程数量过多导致CPU过度调度等问题。
3. 提高程序的响应性：有空闲线程可以直接执行任务，无需新建线程。
4. 提高系统的可扩展性：利用线程池可以更好地扩展一些功能，如定时任务。

## 线程池的参数类型
线程池有以下几个重要的参数类型：
1. corePoolSize：线程池中核心线程数的最大值，用于执行任务的线程数。
2. maximumPoolSize：线程池中线程总数的最大值，包括核心线程和非核心线程。
3. keepAliveTime：非核心线程空闲超时时间，超过该时间将被销毁。
4. unit：keepAliveTime的时间单位。
5. workQueue：存放任务的阻塞队列，用于存放等待执行的任务。

## 线程池的工作原理
线程池的工作原理如下：
1. 当有任务提交时，线程池会首先判断核心线程是否已满，如果未满，则创建新的核心线程来执行任务。
2. 如果核心线程已满，线程池会将任务放入任务队列中进行排队等待执行。
3. 如果任务队列也已满，线程池会判断当前线程总数是否达到最大值，如果未达到，则创建新的非核心线程来执行任务。
4. 如果线程总数已达到最大值，线程池会根据指定的饱和策略来处理无法执行的任务，例如抛出异常或丢弃任务。
5. 当线程池中的线程空闲超过keepAliveTime时，非核心线程会被销毁，以减少资源占用。

## 总结
Java的ThreadPool（线程池）是一种用于管理和复用线程的工具，可以提高系统的性能和响应速度。通过合理配置线程池的参数，可以有效地管理线程资源，减少线程创建和销毁的开销，并提高系统的可扩展性和管理性。

---
Learn more:
1. [Java-线程池ThreadPoolExecutor详解 - 掘金](https://juejin.cn/post/6844904146856837128)
2. [【精选】Java线程池ThreadPool详解_java threadpool_靖节先生的博客-CSDN博客](https://blog.csdn.net/m0_37583655/article/details/122958855)
3. [Java线程池ThreadPoolExecutor详解（一篇就够了） - 星光Starsray - 博客园](https://www.cnblogs.com/starsray/p/16220051.html)

Java的ThreadPool

Tomcat如何扩展Java线程池
=================

在Tomcat中，可以通过定制化的方式来扩展Java线程池，以满足特定的业务需求。下面是关于如何扩展Java线程池的一些总结：



1. Java线程池
----------

Java线程池是通过ThreadPoolExecutor类来创建的，它具有以下参数：

```
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)
```

Java线程池的处理逻辑如下：
- 前corePoolSize个任务，每来一个任务就创建一个新线程。
- 后续的任务会被添加到工作队列workQueue中，等待线程池中的线程来执行。
- 如果工作队列已满，且线程池中的线程数还未达到maximumPoolSize，则会创建临时线程来执行任务。
- 如果线程池中的线程数已达到maximumPoolSize，且工作队列也已满，则会执行拒绝策略handler。

2. Tomcat线程池
------------

Tomcat的线程池是基于ThreadPoolExecutor进行定制化的，主要是为了限制线程个数和队列长度，以避免资源耗尽的风险。以下是Tomcat线程池的一些特点：

2.1 定制版ThreadPoolExecutor

Tomcat构建线程池的代码如下：

```
TaskQueue taskqueue = new TaskQueue();
TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS, taskqueue, tf);
```

- Tomcat定制了任务队列和线程工厂。
- Tomcat对线程数也有限制，设置了核心线程数（minSpareThreads）和最大线程池数量（maxThreads）。

2.2 定制版任务队列

Tomcat的定制版任务队列是TaskQueue，它是对Java的LinkedBlockingQueue进行了扩展。TaskQueue的offer方法被重写，用于控制任务的添加逻辑。具体逻辑如下：

```
public Boolean offer(Runnable o) {
    if (parent == null) {
        return super.offer(o);
    }
    if (parent.getPoolSize() == parent.getMaximumPoolSize()) {
        return super.offer(o);
    }
    if (parent.getSubmittedCount() <= parent.getPoolSize()) {
        return super.offer(o);
    }
    if (parent.getPoolSize() < parent.getMaximumPoolSize()) {
        return false;
    }
    return super.offer(o);
}
```

- 只有当前线程数大于核心线程数、小于最大线程数，并且已提交的任务个数大于当前线程数时，才会创建新的线程。

2.3 总结

Tomcat的线程池扩展了原生的ThreadPoolExecutor，并通过定制版的任务队列TaskQueue来控制线程的创建和任务的添加逻辑。整个线程池的处理逻辑如下：

- 前corePoolSize个任务，每来一个任务就创建一个新线程。
- 后续的任务会被添加到任务队列中，让所有线程去抢。如果已提交的任务大于当前线程数量，则会创建临时线程，直到线程数达到最大线程。
- 如果队列满了（达到了最大线程数量后，继续添加任务到队列导致），执行了拒绝策略。则继续尝试把任务添加到任务队列。
- 如果再次添加队列也失败，执行拒绝策略。

参考资料
-------

1. [Tomcat如何扩展Java线程池 - 掘金](https://juejin.cn/post/6844904197160196103)
2. [tomcat对JUC线程池的扩展 - 知乎](https://zhuanlanTomcat如何扩展Java线程池
=================

Tomcat是一个常用的Java Web服务器，它使用了自定义的线程池来处理请求。在Tomcat中，可以通过定制化的方式来扩展Java线程池，以满足特定的业务需求。

1. Java线程池
----------

Java线程池是通过`ThreadPoolExecutor`类来实现的。它的创建参数包括核心线程数、最大线程数、线程空闲时间、任务队列等。Java线程池的处理逻辑如下：

- 前corePoolSize个任务，每来一个任务就创建一个新线程。
- 后面的任务会被添加到任务队列中，等待线程池中的线程来执行。
- 如果任务队列已满，且线程数还未达到最大线程数，会创建临时线程来执行任务。
- 如果线程数已达到最大线程数，再次提交任务会执行拒绝策略。

2. Tomcat线程池
------------

Tomcat的线程池是基于`ThreadPoolExecutor`的定制版本，它需要限制线程个数和队列长度，以避免资源耗尽的风险。Tomcat构建线程池的代码如下：

```
TaskQueue taskqueue = new TaskQueue();
TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS, taskqueue, tf);
```

Tomcat定制了任务队列和线程工厂，并设置了核心线程数和最大线程数来限制线程数量。

- Tomcat的任务队列是`TaskQueue`，它是对Java的`LinkedBlockingQueue`的扩展。`TaskQueue`重写了`offer`方法，用于控制任务的添加逻辑，以实现弹性创建线程的需求。
- Tomcat的线程工厂是`TaskThreadFactory`，它可以对创建的线程进行重新命名。

3. 总结
-------

Tomcat通过定制化的方式扩展了Java线程池，以满足特定的业务需求。它通过定制的任务队列和线程工厂来限制线程个数和队列长度，并通过重写`execute`方法来实现自己的任务处理逻辑。Tomcat的线程池处理流程如下：

- 前corePoolSize个任务，每来一个任务就创建一个新线程。
- 后面的任务会被添加到任务队列中，让所有线程去抢。如果队列已满，会创建临时线程。
- 如果线程数达到最大线程数，继续尝试将任务添加到任务队列。
- 如果再次添加队列失败，执行拒绝策略。

---
Learn more:
1. [Tomcat如何扩展Java线程池 - 掘金](https://juejin.cn/post/7297522590682873871)
2. [tomcat对JUC线程池的扩展 - 知乎](https://zhuanlan.zhihu.com/p/440141843)
3. [浅谈可扩展线程池 | 青空之蓝](https://blog.ixk.me/post/talk-about-scalable-thread-pool)

Tomcat源码学习17 --ThreadPool

MTR是一种网络诊断工具，可以用于测试网络的连通性和性能。它结合了ping和traceroute的功能，能够提供更详细的网络测试结果。



关于MTR测试平台的一些信息：

1. MTR介绍：
   - MTR全称为My Traceroute，是一个将ping和traceroute功能合并到一个程序中的网络诊断工具[[2]](https://developer.aliyun.com/article/1106415)。
   - 它通过访问指定的IP或域名，列出完整的访问链路，并向链路节点发送ICMP数据包，以确定连接质量[[2]](https://developer.aliyun.com/article/1106415)。

2. MTR的安装：
   - 在Linux系统上，可以通过系统自带的软件源安装MTR[[1]](https://www.ucloud.cn/yun/121703.html)。
   - 在Windows系统上，可以下载名为WinMTR的软件来使用MTR功能[[1]](https://www.ucloud.cn/yun/121703.html)。

3. MTR的使用方法：
   - 在Linux系统上，可以使用命令行来运行MTR测试。例如，可以使用以下命令测试到目标IP地址的连接情况：
     ```
     mtr -r 目标IP地址
     ```
   - MTR会发送ICMP数据包并输出报告，其中包括丢包率、延迟等信息[[1]](https://www.ucloud.cn/yun/121703.html)。

4. MTR结果分析：
   - MTR的报告中包含丢包率、平均延迟、延迟偏差等信息，可以根据这些信息来判断网络质量和故障位置[[1]](https://www.ucloud.cn/yun/121703.html)。



---
Learn more:
1. [新手如何使用MTR工具：Linux网络诊断工具教程 - UCloud云社区](https://www.ucloud.cn/yun/121703.html)
2. [mtr网络监测工具-阿里云开发者社区](https://developer.aliyun.com/article/1106415)
3. [mtr网络链路路由测试工具使用方法及数值结果说明-阿里云开发者社区](https://developer.aliyun.com/article/761051)

网络测试工具mtr

下载了sqlite源码，准备有时间读一下，发现就几个文件，点开一看。。。。一个文件25w行，哈哈
![image.png](/static/img/bf89fae8be88f0eea6c11d22deec5386.image.webp)