高并发请求测试

前言

本篇是关于高并发请求的测试。
高并发请求的情况下，会发生什么事情呢？本文将在测试中为大家解开这个谜题。

环境配置

项目为SpringBoot项目，使用MyBatis作为持久层框架，依赖如下：
1. 提供线程池的工具类需要依赖guava包，由Google提供的；
2. 注意区分数据库连接池和线程池，这俩是不一样的东西。

<dependencies>
	<!-- Web模块，可以省略 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.4</version>
    </dependency>
    <!-- Druid数据库连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.1.22</version>
    </dependency>
    <!-- Guava多线程工具 -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>29.0-jre</version>
    </dependency>
    <!-- 基本的MySQL连接驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <!-- Lombok提供Getter/Setter方法即类日志注解@Slf4j -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

SpringBoot配置文件application.yml如下：
1. 配置了tomcat默认启动的端口号；
2. 配置了数据库连接参数；
3. 配置了MyBatis的参数。

server:
  port: 8888
spring:
  datasource:
    druid:
      # 数据库连接配置
      db-type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/transaction?serverTimezone=GMT%2B8&useAffectedRows=true
      username: root
      password: root
      # 基本连接池数据
      initial-size: 5
      min-idle: 10
      max-active: 20
      max-wait: 5000
mybatis:
  mapper-locations: classpath:mapper/*xml
  type-aliases-package: cn.dylanphang.mysql.pojo
  # 此条让数据库sql语句在控制台中输出
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

所用的数据库表为：

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(30) NOT NULL,
  `password` varchar(30) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

数据库表基本数据：

INSERT INTO `user`(username, password, age)
VALUES
	('dylan', '123456', 18),
	('dora', '123456', 16);

Mapper类及配置：

package cn.dylanphang.mysql.mapper;

import cn.dylanphang.mysql.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

/**
 * @author dylan
 * @date 2020/12/18
 */
@Mapper
@Repository
public interface UserMapper {
    /**
     * 用于查询表的语句，测试事务。
     *
     * @param username username
     * @return user
     */
    User find(String username);

    /**
     * 用于修改表的语句，测试事务。
     *
     * @param username username
     * @param age      age
     */
    void update(String username, Integer age);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="cn.dylanphang.mysql.mapper.UserMapper">
    <select id="find" parameterType="string" resultType="user">
        SELECT *
        FROM user
        WHERE username = #{username};
    </select>

    <update id="update">
        UPDATE user
        SET age = #{param2}
        WHERE username = #{param1}
    </update>

</mapper>

Service层中的休眠设置：

package cn.dylanphang.mysql.service.impl;

import cn.dylanphang.mysql.mapper.UserMapper;
import cn.dylanphang.mysql.pojo.User;
import cn.dylanphang.mysql.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @author dylan
 * @date 2020/12/18
 */
@Service("userService")
@Transactional(rollbackFor = Exception.class)
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    @Override
    public User find(String username) throws InterruptedException {
        Thread.sleep(3000);
        return this.userMapper.find(username);
    }

    @Override
    public void update(String username, Integer age) throws InterruptedException {
        Thread.sleep(3000);
        this.userMapper.update(username, age);
    }
}

线程池工具类：

package cn.dylanphang.mysql.util;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.*;

/**
 * @author dylan
 */
public class ThreadUtils {
    public static void create(Runnable runnable) {

        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
                .setNameFormat("demo-pool-%d").build();
        ExecutorService singleThreadPool = new ThreadPoolExecutor(2000, 4000,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());

        singleThreadPool.execute(runnable);
    }
}

实验开始前需要了解4个参数：
1. initial-size：数据库连接池初始化时创建的连接数，该值不能大于max-active，但可以大于min-idle；
2. min-idle：数据库连接池中所能存在的最小空闲连接数量，该值不能待遇max-active；
3. max-active：数据库连接池中所能存在的最大连接数量，该值需要大于initial-size和min-idle；
4. max-wait：连接的最大等待时长，单位是毫秒。

测试一

测试max-active和max-wait在查询的情况下，其作用和影响。
此时更改数据库连接池的配置为：

initial-size: 1
min-idle: 2
max-active: 2
max-wait: 1000

测试类将创建3个线程同时请求：

package cn.dylanphang.mysql;

import cn.dylanphang.mysql.pojo.User;
import cn.dylanphang.mysql.service.UserService;
import cn.dylanphang.mysql.util.ThreadUtils;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.concurrent.CountDownLatch;

@SpringBootTest
@Slf4j
class MysqlApplicationTests {

    @Resource
    private UserService userService;
    
    @Test
    void testA() throws InterruptedException {
        int maxThread = 3;
        final CountDownLatch cdl = new CountDownLatch(maxThread);
        for (int i = 0; i < maxThread; i++) {
            ThreadUtils.create(() -> {
                try {
                    cdl.await();
                    final User user = this.userService.find("dylan");
                    log.info("User is: {}", user.toString());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            cdl.countDown();
        }
        Thread.sleep(30000);
    }

}

测试结果：

请求过程：
1. 数据库连接池中的最大连接数为2，也就是在同一时间有且仅会允许2个线程获取连接；
2. 数据库连接池中设置的最大等待时间是1秒，当3个线程的请求同时发起，有且仅有2个线程获取到了数据库连接对象，剩余1个线程进入了等待；
3. 测试类中线程处理时间为最少3秒，而连接池中的最大等待时间为1秒，当该线程达到指定的等待时间但仍旧未获取到数据库连接对象时，将抛出GetConnectionTimeoutException；
4. 成功获取数据库连接对象的2个线程在3秒后将成功输出查询到的数据。
从实验中可以知道max-active和max-wait的作用是什么：
- max-active将决定数据库连接池中所能承受的线程上限，而max-wait将决定当超过max-active个线程发出请求时，进入等待流程的线程的最长等待时长是多少；
- 设想场景，但200个并发发起了查询请求，而此时数据库连接池中配置为max-active: 100、max-wait: 1000，而每个查询请求需要处理的时长为2000ms，此时必定只有100查询请求可以完成，但剩余的100个查询请求必定失败；
- 过大的max-active会增加数据库的负担，而过大的max-wait会降低用户的体验。

测试二

测试二将测试2条并发的情况下，事务是否能够顺利完成。
在SpringBoot中事务管理可以通过直接添加@Transactional(rollbackFor = Exception.class)完成。
在UserServiceImpl中添加一个方法，查询用户年龄后，根据年龄进行减一操作后等到新的年龄，再将新的年龄更新为该用户当前的年龄，查询操作后将休眠3秒。

package cn.dylanphang.mysql.service.impl;

import cn.dylanphang.mysql.mapper.UserMapper;
import cn.dylanphang.mysql.pojo.User;
import cn.dylanphang.mysql.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @author dylan
 * @date 2020/12/18
 */
@Service("userService")
@Transactional(rollbackFor = Exception.class)
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    @Override
    public User find(String username) throws InterruptedException {
        Thread.sleep(3000);
        return this.userMapper.find(username);
    }

    @Override
    public void update(String username, Integer age) throws InterruptedException {
        Thread.sleep(3000);
        this.userMapper.update(username, age);
    }

    @Override
    public void findThenUpdate(String username) throws InterruptedException {
        final Integer newAge = this.find(username).getAge() - 1;
        Thread.sleep(3000);
        this.update(username, newAge);
    }
}

测试类：
1. 测试方法只使用了2个线程对数据库发出查询并修改数据的请求，其计算过程是在findThenUpdate中完成的；
2. 测试前后将输出用户年龄前后的值。

package cn.dylanphang.mysql;

import cn.dylanphang.mysql.pojo.User;
import cn.dylanphang.mysql.service.UserService;
import cn.dylanphang.mysql.util.ThreadUtils;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.concurrent.CountDownLatch;

@SpringBootTest
@Slf4j
class MysqlApplicationTests {

    @Resource
    private UserService userService;

    @BeforeEach
    void init() throws InterruptedException {
        final Integer age = this.userService.find("dylan").getAge();
        log.info("Now the age is: {}", age);
    }

    @Test
    void testB() throws InterruptedException {
        int maxThread = 2;
        final CountDownLatch cdl = new CountDownLatch(maxThread);
        for (int i = 0; i < maxThread; i++) {
            ThreadUtils.create(() -> {
                try {
                    cdl.await();
                    this.userService.findThenUpdate("dylan");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            cdl.countDown();
        }
        Thread.sleep(30000);
    }
    
    @AfterEach
    void destroy() throws InterruptedException {
        final Integer age = this.userService.find("dylan").getAge();
        log.info("After the age is: {}", age);
    }

}

@BeforeEach输出：

@Test输出：

@AfterEach输出：

请求过程：
1. 测试类中的2个请求同时发出后，都会先进行数据库查询的操作，无疑2个线程都会获得同一个年龄值；
2. 线程完成Service中的线程倒计时后，此时2个线程都会同时对数据库发起update的操作；
3. 由于更新操作完全一致，导致最终年龄值不是原来年龄值减二后的结果，而仅仅是减一后的结果。
此时可以类比多线程请求购买商品时，商品扣库的情况，即使在有事务控制的情况下，多线程请求同一个接口，对同一个表的同一条数据进行同样的增删改操作，可能会造成数据的不准确，解决方法：
- 将查询和更新语句写在同一条语句中。

测试三

为了解决测试二中出现的并发问题，测试三将把查询和更新语句写在同一条sql语句中，观察输出结果：
- UPDATE user SET age = age - 1 WHERE username = #{username}；
在UserMapper.java中添加一个新的方法，同时在UserMapper.xml中添加相应的Sql语句：

package cn.dylanphang.mysql.mapper;

import cn.dylanphang.mysql.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

/**
 * @author dylan
 * @date 2020/12/18
 */
@Mapper
@Repository
public interface UserMapper {

    /**
     * 使用一条语句进行年龄更新的操作。
     *
     * @param username username
     */
    void findThenUpdateInOneSql(String username);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="cn.dylanphang.mysql.mapper.UserMapper">
    <update id="findThenUpdateInOneSql">
        UPDATE user
        SET age = age - 1
        WHERE username = #{username};
    </update>
</mapper>

相应地，在service层中对线程进行3秒延时处理的模仿：

package cn.dylanphang.mysql.service.impl;

import cn.dylanphang.mysql.mapper.UserMapper;
import cn.dylanphang.mysql.pojo.User;
import cn.dylanphang.mysql.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @author dylan
 * @date 2020/12/18
 */
@Service("userService")
@Transactional(rollbackFor = Exception.class)
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    @Override
    public void findThenUpdateInOneSql(String username) throws InterruptedException {
        Thread.sleep(3000);
        this.userMapper.findThenUpdateInOneSql(username);
    }
}

其中UPDATE user SET age = age - 1 WHERE username = #{username}语句为将年龄减一，再次运行测试：
@BeforeEach输出：

@Test输出：

@AfterEach输出：

此时没有出现类似于测试二中的错误结果。

测试四

经过测试三优化后，我们在同一条sql中完成了更新年龄的操作。
如果此时需要同时处理20000条并发呢？每个线程发送的请求都会获取一个数据库连接对象，而该对象明显是从数据库连接池中取出来的，如果连接池的初始化数量或最小空闲连接数量不足20000，在突然需要处理高并发时，会出现异常。
此时修改连接池的配置为：

initial-size: 10
min-idle: 20
max-active: 40
max-wait: 5000

需要注意的是，关于initial-size初始化连接池数量，该数量不是越大越好的，创建连接对象是十分消耗资源的，该数值配置的越大，启动服务器则会越慢。
所以说，当预计服务器的并发量为20000条时，不可能将initial-size设置为20000，这是不合理的。
同样的，max-active参数也不能设置过大，服务器的资源总是有限的，如果资源大部分用作维护20000个数据库连接对象，无疑也是不合理的，可能会造成系统资源的浪费。
同样使用测试三中的UserMapper.java和UserMapper.xml：

package cn.dylanphang.mysql.mapper;

import cn.dylanphang.mysql.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

/**
 * @author dylan
 * @date 2020/12/18
 */
@Mapper
@Repository
public interface UserMapper {

    /**
     * 使用一条语句进行年龄更新的操作。
     *
     * @param username username
     */
    void findThenUpdateInOneSql(String username);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="cn.dylanphang.mysql.mapper.UserMapper">
    <update id="findThenUpdateInOneSql">
        UPDATE user
        SET age = age - 1
        WHERE username = #{username};
    </update>
</mapper>

同时service层中一样延时3秒：

package cn.dylanphang.mysql.service.impl;

import cn.dylanphang.mysql.mapper.UserMapper;
import cn.dylanphang.mysql.pojo.User;
import cn.dylanphang.mysql.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @author dylan
 * @date 2020/12/18
 */
@Service("userService")
@Transactional(rollbackFor = Exception.class)
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    @Override
    public void findThenUpdateInOneSql(String username) throws InterruptedException {
        Thread.sleep(3000);
        this.userMapper.findThenUpdateInOneSql(username);
    }
}

运行测试，本次过程中出现了GetConnectionTimeoutException和CannotCreateTransactionException：

同时数据库中相关用户的年龄原本为20018，经过20000高并发测试后，结果却为19842：

并发扣减年龄失败的原因，无疑是因为异常导致的。
关于异常的说明：
- GetConnectionTimeoutException：由于在并发的情况下，不能获取到数据库连接的线程，将会进入等待状态，当等待时间超过max-wait中的设定5000ms后，仍未获取到连接，则会抛出此异常；
- CannotCreateTransactionException：本异常的出现，是GetConnectionTimeoutException的一层外壳，其中调用获取数据库连接的方法失败后，捕获到了GetConnectionTimeoutException异常，该方法则抛出此异常：

Exception in thread "demo-pool-0" org.springframework.transaction.CannotCreateTransactionException: 
Could not open JDBC Connection for transaction; nested exception is com.alibaba.druid.pool.GetConnectionTimeoutException: wait millis 9308, active 40, maxActive 40, creating 0

高并发情况下发生异常，基本上都是由于无法获取到数据库连接而导致的。

总结

从测试一中，可以看到决定数据库连接池中连接数量的关键参数是max-active；
从测试二中，可以知道每个线程中的事务，都是独立的：
- 同一个线程的情况，前后两条代码同时使用service中的方法去更新数据库中的同一条数据，后一条代码必定是在前一条代码执行完全结束之后才会执行，而实际开发中，需要将两条代码置于service层中，保证其在一个事务里而不是两个；
- 两个线程的情况下，其中的事务是各自单独执行的，每个线程都回去请求数据库连接池中的连接，每个连接都会开启一个独立的事务，一个事务的异常不会影响另一个事务的执行；
- 多线程下如果需要进行更新库操作，最好的方式是使用同一条sql语句完成操作，先查后计算再更新，有可能导致两个线程中的查询结果一致，直接造成计算结果与更新结果一致的情况。
从测试三中，可以得出将操作置于同一条sql语句，是可以保证事务的一致性；
从测试四中，可以明白在保证事务一致性的前提下，并发量巨大时，系统的短板则会出现在数据库连接池的配置上，同时此配置也无法设置得太大，会影响系统性能。

posted @ 2020-12-18 23:25 phax-ccc 阅读(1388) 评论(0) 编辑收藏举报

刷新页面返回顶部

拼命加载中~

dylan's blog

高并发请求测试

前言

环境配置

测试一

测试二

测试三

测试四

总结

公告