深入理解SpringBoot 最大连接数及最大并发数
更新时间：2023年08月31日 15:11:52 作者：lakernote
SpringBoot能支持的最大并发量主要看其对Tomcat的设置,可以在配置文件中对其进行更改,本文就来介绍一下SpringBoot 最大连接数及最大并发数,感兴趣的可以了解一下
每个Spring Boot版本和内置容器不同，结果也不同，这里以Spring Boot 2.7.10版本 + 内置Tomcat容器举例。
概序
在SpringBoot2.7.10版本中内置Tomcat版本是9.0.73，SpringBoot内置Tomcat的默认设置如下：
- Tomcat的连接等待队列长度，默认是100
- Tomcat的最大连接数，默认是8192
- Tomcat的最小工作线程数，默认是10
- Tomcat的最大线程数，默认是200
- Tomcat的连接超时时间，默认是20s
相关配置及默认值如下
server:
tomcat:
# 当所有可能的请求处理线程都在使用中时，传入连接请求的最大队列长度
accept-count: 100
# 服务器在任何给定时间接受和处理的最大连接数。一旦达到限制，操作系统仍然可以接受基于“acceptCount”属性的连接。
max-connections: 8192
threads:
# 工作线程的最小数量，初始化时创建的线程数
min-spare: 10
# 工作线程的最大数量 io密集型建议10倍的cpu数，cpu密集型建议cpu数+1，绝大部分应用都是io密集型
max: 200
# 连接器在接受连接后等待显示请求 URI 行的时间。
connection-timeout: 20000
# 在关闭连接之前等待另一个 HTTP 请求的时间。如果未设置，则使用 connectionTimeout。设置为 -1 时不会超时。
keep-alive-timeout: 20000
# 在连接关闭之前可以进行流水线处理的最大HTTP请求数量。当设置为0或1时，禁用keep-alive和流水线处理。当设置为-1时，允许无限数量的流水线处理或keep-alive请求。
max-keep-alive-requests: 100架构图
当连接数大于maxConnections+acceptCount + 1时，新来的请求不会收到服务器拒绝连接响应，而是不会和新的请求进行3次握手建立连接，一段时间后（客户端的超时时间或者Tomcat的20s后）会出现请求连接超时。
TCP的3次握手4次挥手
时序图
核心参数
AcceptCount
全连接队列容量，等同于 backlog 参数，与 Linux 中的系统参数 somaxconn 取较小值， Windows 中没有系统参数。
NioEndpoint.java
serverSock = ServerSocketChannel.open(); socketProperties.setProperties(serverSock.socket()); InetSocketAddress addr = new InetSocketAddress(getAddress(), getPortWithOffset()); // 这里 serverSock.socket().bind(addr,getAcceptCount());
MaxConnections
Acccptor.java
// 线程的run方法。
public void run() {
while (!stopCalled) {
// 如果我们已达到最大连接数，等待
connectionLimitLatch.countUpOrAwait();
// 接受来自服务器套接字的下一个传入连接
socket = endpoint.serverSocketAccept()
// socket.close 释放的时候 调用 connectionLimitLatch.countDown(); MinSpareThread/MaxThread
AbstractEndpoint.java
// tomcat 启动时
public void createExecutor() {
internalExecutor = true;
// 容量为Integer.MAX_VALUE
TaskQueue taskqueue = new TaskQueue();
TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
// Tomcat扩展的线程池
executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
taskqueue.setParent( (ThreadPoolExecutor) executor);
}重点重点重点
Tomcat扩展了线程池增强了功能。
- JDK线程池流程：minThreads --> queue --> maxThreads --> Exception
- Tomcat增强后： minThreads --> maxThreads --> queue --> Exception
MaxKeepAliveRequests
长连接，在发送了 maxKeepAliveRequests个请求后就会被服务器端主动断开连接。
在连接关闭之前可以进行流水线处理的最大HTTP请求数量。当设置为0或1时，禁用keep-alive和流水线处理。当设置为-1时，允许无限数量的流水线处理或keep-alive请求。
较大的 MaxKeepAliveRequests 值可能会导致服务器上的连接资源被长时间占用。根据您的具体需求，您可以根据服务器的负载和资源配置来调整 MaxKeepAliveRequests 的值，以平衡并发连接和服务器资源的利用率。
NioEndpoint.setSocketOptions
socketWrapper.setKeepAliveLeft(NioEndpoint.this.getMaxKeepAliveRequests());
Http11Processor.service(SocketWrapperBase<?> socketWrapper)
keepAlive = true;
while(!getErrorState().isError() && keepAlive && !isAsync() && upgradeToken == null &&
sendfileState == SendfileState.DONE && !protocol.isPaused()) {
// 默认100
int maxKeepAliveRequests = protocol.getMaxKeepAliveRequests();
if (maxKeepAliveRequests == 1) {
keepAlive = false;
} else if (maxKeepAliveRequests > 0 &&
//
socketWrapper.decrementKeepAlive() <= 0) {
keepAlive = false;
}ConnectionTimeout
连接的生存周期，当已经建立的连接，在 connectionTimeout 时间内，如果没有请求到来，服务端程序将会主动关闭该连接。
- 在Tomcat 9中，ConnectionTimeout的默认值是20000毫秒，也就是20秒。如果该时间过长，服务器将要等待很长时间才会收到客户端的请求结果，从而导致服务效率低下。
- 如果该时间过短，则可能会出现客户端在请求过程中网络慢等问题，而被服务器取消连接的情况。
- 由于某个交换机或者路由器出现了问题，导致某些post大文件的请求堆积在交换机或者路由器上，tomcat的工作线程一直拿不到完整的文件数据。
NioEndpoint.Poller#run()
// Check for read timeout
if ((socketWrapper.interestOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
long delta = now - socketWrapper.getLastRead();
long timeout = socketWrapper.getReadTimeout();
if (timeout > 0 && delta > timeout) {
readTimeout = true;
}
}
// Check for write timeout
if (!readTimeout && (socketWrapper.interestOps() & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE) {
long delta = now - socketWrapper.getLastWrite();
long timeout = socketWrapper.getWriteTimeout();
if (timeout > 0 && delta > timeout) {
writeTimeout = true;
}
}KeepAliveTimeout
等待另一个 HTTP 请求的时间，然后关闭连接。当未设置时，将使用 connectionTimeout。当设置为 -1 时，将没有超时。
Http11InputBuffer.parseRequestLine
// Read new bytes if needed
if (byteBuffer.position() >= byteBuffer.limit()) {
if (keptAlive) {
// 还没有读取任何请求数据，所以使用保持活动超时
wrapper.setReadTimeout(keepAliveTimeout);
}
if (!fill(false)) {
// A read is pending, so no longer in initial state
parsingRequestLinePhase = 1;
return false;
}
// 至少已收到请求的一个字节 切换到套接字超时。
wrapper.setReadTimeout(connectionTimeout);
}内部线程
Acceptor
Acceptor ： 接收器，作用是接受scoket网络请求，并调用 setSocketOptions() 封装成为 NioSocketWrapper ，并注册到Poller的events中。注意查看run方法 org.apache.tomcat.util.net.Acceptor#run
public void run() {
while (!stopCalled) {
// 等待下一个请求进来
socket = endpoint.serverSocketAccept();
// 注册socket到Poller，生成PollerEvent事件
endpoint.setSocketOptions(socket);
// 向轮询器注册新创建的套接字
- poller.register(socketWrapper);
- (SynchronizedQueue(128))events.add(new PollerEvent(socketWrapper)) Poller
Poller ：轮询器，轮询是否有事件达到，有请求事件到达后，以NIO的处理方式，查询Selector取出所有请求，遍历每个请求的需求，分配给Executor线程池执行。查看 org.apache.tomcat.util.net.NioEndpoint.Poller#run()
public void run() {
while (true) {
//查询selector取出所有请求事件
Iterator<SelectionKey> iterator =
keyCount > 0 ? selector.selectedKeys().iterator() : null;
// 遍历就绪键的集合并调度任何活动事件。
while (iterator != null && iterator.hasNext()) {
SelectionKey sk = iterator.next();
iterator.remove();
NioSocketWrapper socketWrapper = (NioSocketWrapper) sk.attachment();
// 分配给Executor线程池执行处理请求key
if (socketWrapper != null) {
processKey(sk, socketWrapper);
- processSocket(socketWrapper, SocketEvent.OPEN_READ/SocketEvent.OPEN_WRITE)
- executor.execute((Runnable)new SocketProcessor(socketWrapper,SocketEvent))
}
}TomcatThreadPoolExecutor
真正执行连接读写操作的线程池，在JDK线程池的基础上进行了扩展优化。
AbstractEndpoint.java
public void createExecutor() {
internalExecutor = true;
TaskQueue taskqueue = new TaskQueue();
TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
// tomcat自定义线程池
executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
taskqueue.setParent( (ThreadPoolExecutor) executor);
}TomcatThreadPoolExecutor.java
// 与 java.util.concurrent.ThreadPoolExecutor 相同，但实现了更高效的getSubmittedCount()方法，用于正确处理工作队列。
// 如果未指定 RejectedExecutionHandler，将配置一个默认的，并且该处理程序将始终抛出 RejectedExecutionException
public class ThreadPoolExecutor extends java.util.concurrent.ThreadPoolExecutor {
// 已提交但尚未完成的任务数。这包括队列中的任务和已交给工作线程但后者尚未开始执行任务的任务。
// 这个数字总是大于或等于getActiveCount() 。
private final AtomicInteger submittedCount = new AtomicInteger(0);
@Override
protected void afterExecute(Runnable r, Throwable t) {
if (!(t instanceof StopPooledThreadException)) {
submittedCount.decrementAndGet();
}
@Override
public void execute(Runnable command){
// 提交任务的数量+1
submittedCount.incrementAndGet();
try {
// 线程池内部方法，真正执行的方法。就是JDK线程池原生的方法。
super.execute(command);
} catch (RejectedExecutionException rx) {
// 再次把被拒绝的任务放入到队列中。
if (super.getQueue() instanceof TaskQueue) {
final TaskQueue queue = (TaskQueue)super.getQueue();
try {
//强制的将任务放入到阻塞队列中
if (!queue.force(command, timeout, unit)) {
//放入失败，则继续抛出异常
submittedCount.decrementAndGet();
throw new RejectedExecutionException(sm.getString("threadPoolExecutor.queueFull"));
}
} catch (InterruptedException x) {
//被中断也抛出异常
submittedCount.decrementAndGet();
throw new RejectedExecutionException(x);
}
} else {
//不是这种队列，那么当任务满了之后，直接抛出去。
submittedCount.decrementAndGet();
throw rx;
}
}
}/**
* 实现Tomcat特有逻辑的自定义队列
*/
public class TaskQueue extends LinkedBlockingQueue<Runnable> {
private static final long serialVersionUID = 1L;
private transient volatile ThreadPoolExecutor parent = null;
private static final int DEFAULT_FORCED_REMAINING_CAPACITY = -1;
/**
* 强制遗留的容量
*/
private int forcedRemainingCapacity = -1;
/**
* 队列的构建方法
*/
public TaskQueue() {
}
public TaskQueue(int capacity) {
super(capacity);
}
public TaskQueue(Collection<? extends Runnable> c) {
super(c);
}
/**
* 设置核心变量
*/
public void setParent(ThreadPoolExecutor parent) {
this.parent = parent;
}
/**
* put：向阻塞队列填充元素，当阻塞队列满了之后，put时会被阻塞。
* offer：向阻塞队列填充元素，当阻塞队列满了之后，offer会返回false。
*
* @param o 当任务被拒绝后，继续强制的放入到线程池中
* @return 向阻塞队列塞任务，当阻塞队列满了之后，offer会返回false。
*/
public boolean force(Runnable o) {
if (parent == null || parent.isShutdown()) {
throw new RejectedExecutionException("taskQueue.notRunning");
}
return super.offer(o);
}
/**
* 带有阻塞时间的塞任务
*/
@Deprecated
public boolean force(Runnable o, long timeout, TimeUnit unit) throws InterruptedException {
if (parent == null || parent.isShutdown()) {
throw new RejectedExecutionException("taskQueue.notRunning");
}
return super.offer(o, timeout, unit); //forces the item onto the queue, to be used if the task is rejected
}
/**
* 当线程真正不够用时，优先是开启线程（直至最大线程），其次才是向队列填充任务。
*
* @param runnable 任务
* @return false 表示向队列中添加任务失败，
*/
@Override
public boolean offer(Runnable runnable) {
if (parent == null) {
return super.offer(runnable);
}
//若是达到最大线程数，进队列。
if (parent.getPoolSize() == parent.getMaximumPoolSize()) {
return super.offer(runnable);
}
//当前活跃线程为10个，但是只有8个任务在执行，于是，直接进队列。
if (parent.getSubmittedCount() < (parent.getPoolSize())) {
return super.offer(runnable);
}
//当前线程数小于最大线程数，那么直接返回false，去创建最大线程
if (parent.getPoolSize() < parent.getMaximumPoolSize()) {
return false;
}
//否则的话，将任务放入到队列中
return super.offer(runnable);
}
/**
* 获取任务
*/
@Override
public Runnable poll(long timeout, TimeUnit unit) throws InterruptedException {
Runnable runnable = super.poll(timeout, unit);
//取任务超时，会停止当前线程，来避免内存泄露
if (runnable == null && parent != null) {
parent.stopCurrentThreadIfNeeded();
}
return runnable;
}
/**
* 阻塞式的获取任务，可能返回null。
*/
@Override
public Runnable take() throws InterruptedException {
//当前线程应当被终止的情况下：
if (parent != null && parent.currentThreadShouldBeStopped()) {
long keepAliveTime = parent.getKeepAliveTime(TimeUnit.MILLISECONDS);
return poll(keepAliveTime, TimeUnit.MILLISECONDS);
}
return super.take();
}
/**
* 返回队列的剩余容量
*/
@Override
public int remainingCapacity() {
if (forcedRemainingCapacity > DEFAULT_FORCED_REMAINING_CAPACITY) {
return forcedRemainingCapacity;
}
return super.remainingCapacity();
}
/**
* 强制设置剩余容量
*/
public void setForcedRemainingCapacity(int forcedRemainingCapacity) {
this.forcedRemainingCapacity = forcedRemainingCapacity;
}
/**
* 重置剩余容量
*/
void resetForcedRemainingCapacity() {
this.forcedRemainingCapacity = DEFAULT_FORCED_REMAINING_CAPACITY;
}
}JDK线程池架构图
Tomcat线程架构
测试
如下配置举例
server:
port: 8080
tomcat:
accept-count: 3
max-connections: 6
threads:
min-spare: 2
max: 3使用 ss -nlt 查看全连接队列容量。
ss -nltp ss -nlt|grep 8080 - Recv-Q表示（acceptCount）全连接队列目前长度 - Send-Q表示（acceptCount）全连接队列的容量。
静默状态
6个并发连接
结果同上
9个并发连接
10个并发连接
11个并发连接
结果同上
使用 ss -nt 查看连接状态。
ss -ntp ss -nt|grep 8080 - Recv-Q表示客户端有多少个字节发送但还没有被服务端接收 - Send-Q就表示为有多少个字节未被客户端接收。
静默状态
6个并发连接
9个并发连接
补充个netstat
10个并发连接
结果同上，队列中多加了个
11个并发连接
超出连接后，会有个连接一直停留在SYN_RECV状态，不会完成3次握手了。
超出连接后客户端一直就停留在SYN-SENT状态，服务端不会再发送SYN+ACK，直到客户端超时（20s内核控制）断开。
客户端请求超时（需要等待一定时间(20s)）。
这里如果客户端设置了超时时间，要和服务端3次握手超时时间对比小的为准。
12个并发连接
参考
到此这篇关于深入理解SpringBoot 最大连接数及最大并发数的文章就介绍到这了,更多相关SpringBoot 最大连接数及最大并发数内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
您可能感兴趣的文章:
相关文章
这篇文章主要为大家详细介绍了Java实现三子棋小游戏简易版，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2022-05-05
这篇文章主要介绍了Hibernate双向多对多映射关系配置代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-10-10
mybatis调用mysql存储过程(返回参数,单结果集,多结果集)
本文主要介绍了mybatis调用mysql存储过程(返回参数,单结果集,多结果集)，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2022-01-01
SpringBoot下使用MyBatis-Puls代码生成器的方法
这篇文章主要介绍了SpringBoot下使用MyBatis-Puls代码生成器的方法，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下2020-10-10
下面小编就为大家分享一篇java 文件和byte互转的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2017-11-11
MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注SQL本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码，本文将作为最终篇为大家介绍MyBatis的使用2022-07-07
Mybatis是业界非常流行的持久层框架，轻量级、易用，在金融IT领域完全是领军地位，比Hibernate更受欢迎，优势非常多，也是非常值得我们学习的。这篇文章主要介绍了Mybatis的缺陷问题的相关资料,需要的朋友可以参考下2016-10-10
enum的全称为enumeration， 是 JDK 1.5中引入的新特性，存放在 java.lang包中。下面这篇文章是我在使用enum过程中的一些经验和总结，分享出来方便大家快速的掌握Java中枚举(enum)，有需要的朋友们下面跟着小编来一起看看吧。2016-12-12
数据库在保存数据时，对于某些敏感数据需要脱敏或者加密处理，本文主要介绍了mybatis-plus 拦截器敏感字段加解密的实现，感兴趣的可以了解一下2021-11-11
这篇文章主要介绍了Java实用工具之StringJoiner详解,文中有非常详细的代码示例,对正在学习java的小伙伴们有很好地帮助,需要的朋友可以参考下2021-05-05
最新评论