JAVA Gatling 压测时 QPS 上不去？连接池、线程池组合调优 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，我们开始今天的讲座。

JAVA Gatling 压测时 QPS 上不去？连接池、线程池组合调优

大家好，今天我们来聊聊在使用 Gatling 进行 Java 应用压测时，QPS (Queries Per Second) 上不去的问题，以及如何通过连接池和线程池的组合调优来解决这个问题。

问题诊断：为什么 QPS 上不去？

在压测过程中，QPS 上不去通常不是单一原因造成的，需要系统性的分析。以下是一些常见的原因：

资源瓶颈:
- CPU: 服务器 CPU 资源耗尽，导致无法处理更多的请求。
- 内存: 内存不足导致频繁的 GC (Garbage Collection)，影响性能。
- 网络: 带宽限制，网络延迟，连接数限制等。
- 磁盘 I/O: 频繁的磁盘读写操作导致性能下降。
数据库瓶颈:
- 数据库连接池: 连接池配置不合理，导致获取连接的时间过长。
- SQL 语句效率: SQL 语句执行效率低下，消耗大量数据库资源。
- 数据库服务器资源: 数据库服务器 CPU、内存、磁盘 I/O 达到瓶颈。
应用代码瓶颈:
- 线程池配置: 线程池大小不合适，导致任务排队等待。
- 锁竞争: 过多的锁竞争导致线程阻塞。
- 阻塞 I/O: 同步 I/O 操作导致线程长时间等待。
- 代码效率: 低效的代码逻辑，例如复杂的循环，导致 CPU 占用率过高。
Gatling 脚本问题:
- 模拟用户数不足: 模拟用户数不足以产生足够的负载。
- 请求间隔过长: 请求之间间隔时间过长，导致 QPS 上不去。
- 脚本逻辑错误: 脚本逻辑不合理，例如错误的参数设置，导致请求失败。
外部依赖:
- 第三方服务延迟: 依赖的第三方服务响应缓慢。
- 缓存失效: 缓存失效导致频繁的请求到达后端服务。

排查步骤：

监控系统资源: 使用监控工具 (例如 Prometheus, Grafana, JConsole, VisualVM) 监控服务器 CPU、内存、网络、磁盘 I/O 等资源的使用情况。
监控数据库: 使用数据库监控工具 (例如 MySQL Workbench, pgAdmin) 监控数据库连接数、SQL 执行时间、资源使用情况。
分析 Gatling 报告: 查看 Gatling 报告，分析请求的响应时间、错误率、吞吐量等指标。
代码分析: 使用 Profiler (例如 JProfiler, YourKit) 分析代码性能，找出性能瓶颈。
日志分析: 分析应用日志，查看是否有异常信息，例如连接超时，SQL 执行错误等。

连接池调优

连接池是管理数据库连接的重要组件，合理的配置可以显著提高应用的性能。

连接池类型选择: 常用的连接池有 HikariCP, DBCP, C3P0 等。HikariCP 在性能方面表现更优，推荐使用。

核心参数:

参数名称	描述	调优建议
`maximumPoolSize`	连接池中允许的最大连接数。	设置过小会导致连接不够用，设置过大会占用过多数据库资源。需要根据实际负载进行调整。通常设置为 (CPU核心数 * 2) + 1，并根据实际情况进行调整。
`minimumIdle`	连接池中保持的最小空闲连接数。	设置过小会导致频繁创建连接，设置过大会占用过多数据库资源。通常设置为与 `maximumPoolSize` 相同，或者略小。
`idleTimeout`	连接空闲多久后会被回收。	设置过小会导致频繁创建和销毁连接，设置过大会占用过多数据库资源。根据数据库连接的生命周期和业务特点进行调整。例如设置为 10 分钟到 30 分钟。
`maxLifetime`	连接的最大生命周期。	设置过小会导致频繁创建和销毁连接，设置过大会导致连接失效。根据数据库服务器的配置和业务特点进行调整。例如设置为 30 分钟到 1 小时。
`connectionTimeout`	获取连接的最大等待时间。	设置过小会导致获取连接失败，设置过大会导致请求长时间等待。通常设置为几秒钟到几十秒钟。
`validationTimeout`	连接有效性验证的超时时间。	用于检测连接是否有效，防止使用失效的连接。设置一个合理的超时时间，例如几秒钟。
`leakDetectionThreshold`	检测连接泄漏的阈值。	用于检测连接是否被正确释放，防止连接泄漏。设置一个合理的阈值，例如 10 秒钟。
`poolName`	连接池的名称，用于监控和日志记录。	建议设置一个有意义的名称，方便排查问题。
`dataSourceClassName`	数据库驱动类的名称。	根据使用的数据库类型进行设置。
`jdbcUrl`	数据库连接 URL。	包含数据库服务器地址、端口、数据库名称等信息。
`username`	数据库用户名。	用于连接数据库。
`password`	数据库密码。	用于连接数据库。
`connectionTestQuery`	连接测试 SQL 语句。	用于检测连接是否有效。

HikariCP 配置示例:
```
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/test");
config.setUsername("root");
config.setPassword("password");
config.setDriverClassName("com.mysql.cj.jdbc.Driver");

config.setMaximumPoolSize(20);
config.setMinimumIdle(5);
config.setIdleTimeout(600000); // 10 minutes
config.setMaxLifetime(1800000); // 30 minutes
config.setConnectionTimeout(30000); // 30 seconds
config.setValidationTimeout(5000); // 5 seconds
config.setLeakDetectionThreshold(10000); // 10 seconds
config.setPoolName("MyHikariCP");

HikariDataSource ds = new HikariDataSource(config);
```
代码解释：
- HikariConfig：用于配置 HikariCP 连接池。
- setJdbcUrl，setUsername，setPassword，setDriverClassName：设置数据库连接信息。
- setMaximumPoolSize：设置最大连接数为 20。
- setMinimumIdle：设置最小空闲连接数为 5。
- setIdleTimeout：设置连接空闲 10 分钟后会被回收。
- setMaxLifetime：设置连接的最大生命周期为 30 分钟。
- setConnectionTimeout：设置获取连接的超时时间为 30 秒。
- setValidationTimeout：设置连接有效性验证的超时时间为 5 秒。
- setLeakDetectionThreshold：设置连接泄漏检测阈值为 10 秒。
- setPoolName：设置连接池名称为 "MyHikariCP"。
- HikariDataSource：创建 HikariCP 数据源。

线程池调优

线程池用于管理并发任务，合理的配置可以提高应用的并发处理能力。

线程池类型选择: 常用的线程池有 FixedThreadPool, CachedThreadPool, ScheduledThreadPool, ForkJoinPool 等。根据实际需求选择合适的线程池类型。

核心参数:

参数名称	描述	调优建议
`corePoolSize`	核心线程数。	线程池中始终保持的线程数。设置过小会导致任务排队等待，设置过大会占用过多系统资源。通常设置为 CPU 核心数，或者 CPU 核心数 + 1。
`maximumPoolSize`	最大线程数。	线程池中允许的最大线程数。当任务队列满了之后，线程池会创建新的线程来处理任务，直到达到最大线程数。设置过小会导致任务被拒绝，设置过大会占用过多系统资源。通常设置为 corePoolSize 的 2 倍到 4 倍，或者根据实际负载进行调整。
`keepAliveTime`	空闲线程的存活时间。	当线程池中的线程数大于 corePoolSize 时，空闲线程会在指定时间内被回收。设置过小会导致频繁创建和销毁线程，设置过大会占用过多系统资源。通常设置为几秒钟到几分钟。
`unit`	`keepAliveTime` 的时间单位。	例如 `TimeUnit.SECONDS`, `TimeUnit.MINUTES`。
`workQueue`	任务队列。	用于存储等待执行的任务。常用的任务队列有 `ArrayBlockingQueue`, `LinkedBlockingQueue`, `SynchronousQueue` 等。选择合适的任务队列可以影响线程池的性能。
`threadFactory`	线程工厂。	用于创建新的线程。可以自定义线程工厂来设置线程的名称、优先级等。
`rejectedExecutionHandler`	拒绝策略。	当任务队列满了并且线程池中的线程数达到了最大线程数时，线程池会执行拒绝策略。常用的拒绝策略有 `AbortPolicy`, `CallerRunsPolicy`, `DiscardPolicy`, `DiscardOldestPolicy` 等。

ThreadPoolExecutor 配置示例:

import java.util.concurrent.*;

public class ThreadPoolExample {

    public static void main(String[] args) {
        int corePoolSize = 10;
        int maximumPoolSize = 20;
        long keepAliveTime = 60;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(100);
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.AbortPolicy();

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                threadFactory,
                rejectedExecutionHandler
        );

        for (int i = 0; i < 1000; i++) {
            int taskNumber = i;
            executor.execute(() -> {
                System.out.println("Task " + taskNumber + " is running in thread " + Thread.currentThread().getName());
                try {
                    Thread.sleep(100); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
        try {
            executor.awaitTermination(10, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("All tasks finished.");
    }
}

代码解释：

corePoolSize：设置核心线程数为 10。
maximumPoolSize：设置最大线程数为 20。
keepAliveTime：设置空闲线程的存活时间为 60 秒。
unit：设置时间单位为秒。
workQueue：使用 ArrayBlockingQueue 作为任务队列，容量为 100。
threadFactory：使用默认的线程工厂。
rejectedExecutionHandler：使用 AbortPolicy 作为拒绝策略，当任务队列满了并且线程池中的线程数达到了最大线程数时，会抛出 RejectedExecutionException 异常。
executor.execute()：提交任务到线程池执行。
executor.shutdown()：关闭线程池，不再接受新的任务。
executor.awaitTermination()：等待所有任务执行完成。

Gatling 脚本优化

Gatling 脚本的优化可以提高压测的效率和准确性。

模拟真实用户行为: 尽可能模拟真实用户的行为模式，例如用户登录，浏览商品，添加到购物车，下单等。
参数化请求: 使用参数化请求可以模拟不同的用户输入，例如不同的用户名，密码，商品 ID 等。
使用 feeders: 使用 feeders 可以从 CSV 文件，JSON 文件，数据库等读取数据，作为请求的参数。
设置合适的请求间隔: 设置合适的请求间隔可以模拟真实用户的访问频率。
使用 assertions: 使用 assertions 可以验证请求的响应是否符合预期。
优化脚本逻辑: 避免在脚本中执行复杂的计算逻辑，尽量将计算逻辑放在后端服务中。
减少请求数量: 合并多个请求为一个请求，减少网络开销。
使用缓存: 在 Gatling 脚本中使用缓存可以减少对后端服务的请求数量。

Gatling 脚本示例:

import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._

class BasicSimulation extends Simulation {

  val httpProtocol = http
    .baseUrl("http://localhost:8080") // 设置基本 URL
    .acceptHeader("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8") // 设置 Accept Header
    .doNotTrackHeader("1")
    .acceptLanguageHeader("en-US,en;q=0.5")
    .acceptEncodingHeader("gzip, deflate")
    .userAgentHeader("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36")

  val scn = scenario("Basic Simulation") // 定义一个 Scenario
    .exec(http("request_1") // 定义一个 HTTP 请求
      .get("/")) // 设置请求方法和 URL
    .pause(5) // 暂停 5 秒
    .exec(http("request_2")
      .get("/users"))
    .pause(5)

  setUp(
    scn.inject(rampUsers(100).during(20.seconds)) // 设置并发用户数和 ramp up 时间
  ).protocols(httpProtocol) // 设置 HTTP 协议
}

代码解释：

httpProtocol：定义 HTTP 协议，包括基本 URL，Header 等信息。
scn：定义一个 Scenario，包含多个 HTTP 请求和 pause。
exec(http("request_1").get("/"))：定义一个 HTTP GET 请求，URL 为 "/"。
pause(5)：暂停 5 秒。
setUp：设置并发用户数和 ramp up 时间，以及使用的 HTTP 协议。
rampUsers(100).during(20.seconds)：在 20 秒内 ramp up 到 100 个用户。

JVM 调优

JVM 调优可以提高应用的性能和稳定性。

选择合适的 GC 算法: 常用的 GC 算法有 Serial GC, Parallel GC, CMS GC, G1 GC 等。根据应用的特点选择合适的 GC 算法。通常情况下，G1 GC 在大多数场景下表现更优。
设置合适的堆大小: 设置合适的堆大小可以减少 GC 的频率和时间。需要根据应用的内存使用情况进行调整。
调整 GC 参数: 调整 GC 参数可以优化 GC 的性能。例如调整新生代和老年代的大小，设置 GC 的阈值等。
使用 JIT 编译器: JIT 编译器可以将热点代码编译成机器码，提高代码的执行效率。
监控 JVM 性能: 使用监控工具 (例如 JConsole, VisualVM) 监控 JVM 的性能，例如 CPU 使用率，内存使用率，GC 时间等。
JVM 参数示例:
```
-Xms4g -Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:InitiatingHeapOccupancyPercent=45
```
参数解释：
- -Xms4g：设置 JVM 初始堆大小为 4GB。
- -Xmx4g：设置 JVM 最大堆大小为 4GB。
- -XX:+UseG1GC：使用 G1 GC 算法。
- -XX:MaxGCPauseMillis=200：设置最大 GC 暂停时间为 200 毫秒。
- -XX:InitiatingHeapOccupancyPercent=45：设置 InitiatingHeapOccupancyPercent 为 45%，即当堆使用率达到 45% 时，触发 GC。

数据库优化

数据库优化是提高应用性能的重要环节。

索引优化: 创建合适的索引可以提高 SQL 语句的查询效率。
SQL 语句优化: 编写高效的 SQL 语句可以减少数据库的资源消耗。
数据库服务器优化: 优化数据库服务器的配置，例如调整内存大小，调整缓存大小等。
使用连接池: 使用连接池可以减少数据库连接的创建和销毁开销。
读写分离: 使用读写分离可以提高数据库的并发处理能力。
分库分表: 当单表数据量过大时，可以考虑分库分表。
缓存: 使用缓存可以减少对数据库的请求数量。

代码优化

代码优化是提高应用性能的基础。

减少对象创建: 减少不必要的对象创建可以减少内存开销和 GC 的频率。
使用 StringBuilder: 使用 StringBuilder 可以避免 String 对象的频繁创建。
使用缓存: 使用缓存可以减少对资源的重复获取。
优化算法: 选择合适的算法可以提高代码的执行效率。
避免阻塞 I/O: 使用异步 I/O 可以提高应用的并发处理能力。
减少锁竞争: 减少锁竞争可以提高应用的并发性能。
使用 Profiler: 使用 Profiler 可以找出代码的性能瓶颈。

总结：多方位的调优策略

通过对连接池、线程池、Gatling 脚本、JVM、数据库和代码进行全方位的优化，可以有效地提高 Gatling 压测时的 QPS。需要根据实际情况进行调整和测试，找到最佳的配置方案。记住，优化是一个持续的过程，需要不断地监控和调整。

发表回复 取消回复

发表回复取消回复