奋斗
努力

如何优化云服务器上的资源以运行更多的Spring Boot应用?

云计算

先说结论:想在一台云服务器上跑更多 Spring Boot 应用,核心不是找几个“神奇 JVM 参数”,而是做四件事:应用瘦身、JVM 控内存、系统层资源隔离、基于压测确定容量。
如果业务量已经上来,优先横向扩展;单机高密度会带来故障半径变大、发布抖动、GC 抢 CPU 等问题。

下面按实战顺序说。


1. 先算清楚资源预算,不要凭感觉塞应用

一台机器上能跑多少 Spring Boot,主要看这几个瓶颈:

可部署实例数 ≈ min(
  (可用内存 - 系统预留 - 监控/日志预留) / 单实例峰值 RSS,
  CPU 可承载实例数,
  磁盘 IO / 网络 / 连接池承载能力
)

不要只看 -Xmx。一个 Spring Boot 进程实际占用的 RSS 通常包括:

Java Heap
Metaspace
Code Cache
Thread Stack
Direct Memory
GC 结构
JIT / JVM 自身开销
Native Memory
共享库、文件映射

所以你给容器 1GB,不代表 -Xmx1g 就安全。比较稳的做法是:堆内存只占容器内存限制的 50%~65%,剩下的留给非堆和系统开销。

一般建议:

资源 建议水位
CPU 长期使用率 50%~70%
内存可用量 至少保留 20%~30%
Load 不要长期超过 CPU 核数的 1~1.5 倍
磁盘 IO await 明显升高就别继续塞
GC 时间 STW 和业务 P99 要一起看

2. JDK 和 JVM 参数要适配云环境

新项目尽量用 JDK 17 或 JDK 21 LTS。Spring Boot 3 要求 Java 17+,容器感知、GC、SIG 等方面也比老 JDK 稳很多。

如果是 JDK 8,建议至少使用较新的 8u 版本;老版本对 cgroups 支持不完整,容易出现“容器给了 1GB,JVM 却按宿主机 32GB 去算堆”的问题。

容器里的 JVM 示例

假设容器限制 1GB 内存:

java 
  -XX:+UseContainerSupport 
  -XX:InitialRAMPercentage=25 
  -XX:MaxRAMPercentage=55 
  -XX:MaxMetaspaceSize=192m 
  -XX:MaxDirectMemorySize=256m 
  -Xss512k 
  -XX:+UseG1GC 
  -jar app.jar

含义大概是:

  • MaxRAMPercentage=55:堆最大约 550MB;
  • MaxMetaspaceSize=192m:限制类元数据;
  • MaxDirectMemorySize=256m:限制堆外内存,Netty、WebClient、gRPC、HTTP Client 场景尤其要关注;
  • -Xss512k:降低线程栈占用,默认 1MB 在多实例、多线程场景下很吃内存;
  • UseContainerSupport:让 JVM 感知容器内存和 CPU 限制。

注意:-Xss 不要盲目降到 128k,递归、复杂调用栈、某些框架X_X可能出问题。一般从 512k 开始压测。

GC 选择

常规 Web 服务:

-XX:+UseG1GC

G1 是 JDK 9 之后的默认 GC,适合大多数中小堆服务。

小内存、低并发内部服务可以评估 Serial GC:

-XX:+UseSerialGC

它能减少 GC 线程和部分内存开销,但停顿会更明显,不适合高 QPS、低延迟接口。

ZGC 适合低延迟和大堆场景,但自身有 CPU 和内存成本。单机高密度塞很多应用时,ZGC 未必划算。


3. Spring Boot 本身要瘦身

很多 Spring Boot 应用“胖”,不是业务复杂,而是依赖和默认配置没收敛。

依赖裁剪

检查是否有这些情况:

  • 引了大量 starter,但实际只用了很小一部分;
  • 不用 Web 却引入 spring-boot-starter-web;
  • 同时引入多套 HTTP 客户端;
  • 只是为了一个工具类引入大型 SDK;
  • 全局扫描包过大,启动加载了大量 Bean。

建议:

@SpringBootApplication(scanBasePackages = "com.xxx.order")

不要让 Spring 从过大的根包扫描。

如果只是普通 REST 服务,Tomcat、Undertow、Netty 都可以,但别迷信某个容器一定更省。Undertow 在某些高并发长连接场景线程模型更轻,但生态和排查体验要一起考虑,最终以压测为准。

线程池别开太大

Spring Boot 默认 Tomcat 最大线程数通常是 200。单机跑多个应用时,如果每个实例都保留 200 线程,线程栈、上下文切换都会上来。

可以按并发量调整:

server.tomcat.threads.min-spare=10
server.tomcat.threads.max=100
server.tomcat.accept-count=100

不要觉得线程越多吞吐越高。CPU 就那么几核,线程太多只会增加调度成本。

数据库连接池同理:

spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=2

真实上限要看数据库能承受多少连接。很多场景不是应用不够快,而是数据库连接池开太大,把数据库打爆。

日志要克制

日志是最容易被忽略的资源消耗点。

建议:

  • 生产环境不要开 DEBUG;
  • 高频链路减少无意义日志;
  • 用异步日志时控制队列大小,防止堆积吃掉内存;
  • 配置日志滚动,避免磁盘被写满;
  • 云上可以把日志采集到日志服务,比如阿里云 SLS、腾讯云 CLS、华为云 LTS 等。

Actuator 也别全量暴露:

management.endpoints.web.exposure.include=health,info
management.endpoint.health.show-details=never

4. 用 systemd、Docker 或 K8s 做资源隔离

如果只是少量应用,裸跑 jar 也可以,但至少用 systemd 管起来。

systemd 示例

[Unit]
Description=order-service
After=network.target

[Service]
User=app
WorkingDirectory=/data/apps/order
ExecStart=/usr/bin/java -XX:MaxRAMPercentage=55 -Xss512k -jar order.jar
Restart=always
LimitNOFILE=65535
MemoryHigh=1200M
MemoryMax=1400M
CPUQuota=100%
TasksMax=512

[Install]
WantedBy=multi-user.target

几个点:

  • MemoryHigh:接近限制时内核会积极回收;
  • MemoryMax:硬限制,超过会触发 OOM;
  • CPUQuota=100%:最多约等于一个核;
  • TasksMax:防止线程/进程爆炸;
  • LimitNOFILE:文件句柄数。

这种方式适合“一台机器上跑 5~10 个服务”的场景。

Docker 更方便标准化

docker run -d 
  --name order-service 
  --memory=1g 
  --cpus=1 
  --pids-limit=256 
  -e JAVA_TOOL_OPTIONS="-XX:MaxRAMPercentage=55 -Xss512k" 
  order-service:latest

同时要配置日志滚动:

--log-driver=json-file 
--log-opt max-size=100m 
--log-opt max-file=3

否则容器日志可能悄悄把云盘写满。

规模上来就用容器服务

如果应用数量较多,建议直接用云厂商容器服务:

  • 阿里云 ACK;
  • 腾讯云 TKE;
  • 华为云 CCE;
  • 火山引擎 VKE。

K8s 里重点是设置 requests 和 limits:

resources:
  requests:
    cpu: "300m"
    memory: "512Mi"
  limits:
    cpu: "1"
    memory: "1Gi"

注意:
JVM 堆上限要小于容器 memory limit。
如果 limit=1Gi,你设置 -Xmx1g,基本是在等 OOMKilled。


5. Linux 系统层也要调

文件句柄

多应用、多连接场景下,ulimit -n 太小会出现 Too many open files。

systemd 服务里:

LimitNOFILE=65535

容器里:

--ulimit nofile=65535:65535

Swap 不要粗暴处理

小内存机器上,完全关 swap 可能导致突发流量直接 OOM。
保留少量 swap 或 zram 可以兜底,但会引入延迟。

如果业务对延迟敏感,建议:

vm.swappiness=1

不要设成 60 甚至更高,否则内存稍微紧张就开始换页,Java 服务会很难受。

THP

Transparent Huge Pages 对某些 Java 应用会造成 GC 延迟抖动。生产上常见做法是关闭或改为 madvise:

echo never > /sys/kernel/mm/transparent_hugepage/enabled
echo never > /sys/kernel/mm/transparent_hugepage/defrag

但这不是绝对规则,最好结合 GC 日志和延迟指标判断。

磁盘和网络

多应用共享一台云服务器时,磁盘 IO 也很关键:

  • 日志、临时文件、上传目录不要和系统盘混得过于混乱;
  • 优先 SSD / ESSD 云盘;
  • 关注 iowait、await、util;
  • Nginx、日志采集、JAVA 进程日志同时写盘时,IO 可能先成为瓶颈。

6. 把公共能力从 Java 应用里拿出去

提高单机密度的关键,是让 Spring Boot 只做业务。

这些能力不建议和一堆 Java 应用挤在同一台机器上:

  • MySQL / PostgreSQL;
  • Redis;
  • Elasticsearch;
  • Kafka / RabbitMQ;
  • 大文件存储;
  • 定时任务调度中心;
  • 监控存储。

云上更推荐用托管服务:

  • 云数据库 RDS;
  • 云 Redis;
  • 消息队列;
  • 对象存储 OSS / COS / OBS;
  • 日志服务;
  • 负载均衡 CLB / SLB / ELB。

尤其是 TLS 和静态资源,建议交给负载均衡或 Nginx:

用户 -> CLB/SLB -> Nginx -> Spring Boot

这样 Java 应用不用每个都处理证书、HTTP 连接保持、静态文件响应,CPU 和线程都能省下来。


7. 云上不要只盯着单台机器

如果目标是“总共跑更多应用”,单机塞满通常不是最优解。

更稳的方案是:

  1. 负载均衡后面挂多个实例;
  2. 配置弹性伸缩;
  3. 使用容器服务调度;
  4. 按 CPU、内存、QPS 或自定义指标扩容;
  5. 关键服务留冗余。

国内云厂商这类能力都比较成熟,比如:

  • 阿里云 ECS + SLB + ASM/ACK + ARMS/SLS;
  • 腾讯云 CVM + CLB + TKE + CLS;
  • 华为云 ECS + ELB + CCE;
  • 火山引擎 ECS + CLB + VKE。

生产环境不建议长期使用突发性能型实例扛持续高负载。CPU 信用额度耗尽后,性能会明显下降,表现为接口突然变慢。


8. 监控和压测决定最终能跑多少

不要靠“看起来还行”决定实例数量。至少看这些指标:

系统层

top
vmstat 1
pidstat -u -r -d 1
iostat -x 1
ss -s
free -m

重点看:

  • CPU 使用率和 iowait;
  • 上下文切换;
  • 内存 available;
  • swap in/out;
  • 磁盘 await / util;
  • 连接数;
  • 文件句柄数。

JVM 层

jstat -gcutil <pid> 1000
jcmd <pid> VM.native_memory summary
jcmd <pid> Thread.print

可以接入:

  • Prometheus + Grafana;
  • Spring Boot Actuator + Micrometer;
  • Arthas;
  • async-profiler;
  • JFR;
  • 云厂商应用监控。

重点看:

  • Heap 使用曲线;
  • Young GC / Full GC 次数和耗时;
  • Metaspace;
  • Direct Memory;
  • 线程数;
  • 数据库连接池等待;
  • HTTP 线程池队列;
  • P95 / P99 延迟。

压测

用 wrk、k6、JMeter 都可以。
压测时不要只看平均响应时间,要看:

  • P95 / P99;
  • 错误率;
  • GC 暂停;
  • CPU 跑满时是否雪崩;
  • 内存是否缓慢增长;
  • 连接数上来后线程是否爆炸。

9. 常见误区

  1. -Xmx 设得越大越稳
    不对。堆太大可能导致 GC 停顿变长,也会挤占非堆和系统内存。

  2. 容器内存等于堆内存
    不对。堆、元空间、直接内存、线程栈都要算进去。

  3. 线程数、连接池越大吞吐越高
    不对。过大只会增加上下文切换和下游压力。

  4. 日志开 DEBUG 方便排查
    生产长期 DEBUG 会明显增加 CPU、磁盘 IO 和日志采集压力。

  5. 单机能塞就一直塞
    发布、重启、故障、GC、流量峰值都会互相影响。生产要留冗余。

  6. 测试环境跑得动,生产也没问题
    测试环境流量模型和生产往往完全不同,最终容量必须靠生产灰度或接近真实压测确认。


一个比较稳的落地方案

假设一台 4核 16GB 云服务器,跑普通 Spring Boot REST 服务,可以这样起步:

系统和监控预留:3GB
可用给应用:约 12GB
单应用容器限制:1GB~1.5GB
单应用堆:500MB~800MB
单应用 CPU limit:0.5~1 核
保留 20%~30% 冗余

也就是先放 8~10 个轻量服务,再根据压测和监控调整。

如果是 2核 4GB,不要塞太多,通常 2~3 个轻服务就差不多了。每个服务限制 512MB~1GB 内存,堆控制在 256MB~512MB,并保留系统内存。

最终原则很简单:

先限制每个应用最多能用多少,再测它真实需要多少,最后在不牺牲稳定性的前提下提高密度。

未经允许不得转载:云服务器 » 如何优化云服务器上的资源以运行更多的Spring Boot应用?