高并发

2020-07-05

基准测试

环境

ThinkPad E14 
CPU: AMD 4500U
内存: 16G
JDK: 1.8
测试工具:Jmeter
负载:1000线程  ramp-up 5秒 1000循环次数

执行语句

jmeter -n -t 测试计划.jmx -l results.log -e -o out

eg.1

@RequestMapping("buy/get")
public String buy_get() {
    Jedis jedis = jedisPool.getResource();
    String res = jedis.get("jedis:test-99");
    jedis.close();
    return res;
}

TPS: 13926.99 13899.51 18116.93

eg.2

@RequestMapping("buy/get2")
public String buy_get2() {
    return RedisUtil.get("jedis:test-99");
}

TPS: 14203.74 18032.31 14112.73

eg.3

@RequestMapping("buy/get3")
public String buy_get3() {
    ValueOperations operations = redisTemplate.opsForValue();
    return (String) operations.get("RedisTemplate:test-99");
}

TPS: 11842.17 11517.69 11489.50

eg.4

@RequestMapping("buy/get4")
public String buy_get4() {
    return RedisUtil2.strings().get("jedis:test-99");
}

TPS: 17779.36 12976.56 17614.63

eg.5

@RequestMapping("buy/get5")
public R buy_get5() {
    return R("malu99");
}

TPS: 18562.52 21023.86 20304.16

eg.6

@RequestMapping("buy/get6")
public String buy_get6() {
    return "malu99";
}

TPS: 21628.64 23030.86 22103.36

加入负载因子(限流计数器)

eg.1

加入负载因子对性能几乎没损耗,不过该方案线程不安全

private static int l = 0;
private static long my = 0;

@RequestMapping("buy/factor1")
public String buy_factor1() {
    l++;
    if ((l % 10) == 0) {
        l = 0;
        my++;
        return "malu"+my;
    } else {
        return "error";
    }
}

TPS: 22849.83 22617.27 21693.86

返回结果:

第一次 第二次 第三次
malu99654 malu99671 malu99517

eg.2

接下来写入service来做更多的测试,首先测没有负载因子的情况:

buyController

@Autowired
buyService buyService;

@RequestMapping("buy/factor2")
public R buy_factor2() {
    return buyService.factor2();
}

buyService

public interface buyService {
    R factor2();
}

buyServiceImpl

@Service
public class buyServiceImpl implements buyService {
    @Override
    public R factor2() {
        return R();
    }
}

TPS: 19955.70 19022.98 20781.38

eg.3

使用私有静态属性,在多线程情况下不安全:

private static int l = 0;
private static long my = 0;

@Override
public R factor3(){
    l++;
    if ((l % 10) == 0) {
        l = 0;
        my++;
        return R("malu"+my);
    } else {
        return R("error");
    }
}

TPS: 22611.13 20362.87 19967.25

返回结果:

第一次 第二次 第三次
malu99815 malu99885 malu99852

eg.4

为了线程安全,首先想到的是同步方法

/**
 * 同步方法
 *
 * @return
 */
@Override
synchronized public R factor4() {
    l++;
    if ((l % 10) == 0) {
        l = 0;
        my++;
        return R("malu" + my);
    } else {
        return R("error");
    }
}

TPS: 18390.13 19664.91 18653.93

返回结果(线程安全):

第一次 第二次 第三次
malu100001 malu100001 malu100001

eg.5

同步代码段一样可以

/**
 * 同步代码段
 *
 * @return
 */
@Override
public R factor5() {
    synchronized (buyServiceImpl.class) {
        l++;
        if ((l % 10) == 0) {
            l = 0;
            my++;
            return R("malu" + my);
        } else {
            return R("error");
        }
    }
}

TPS: 19155.99 20210.59 20727.11

返回结果(线程安全):

第一次 第二次 第三次
malu100001 malu100001 malu100001

eg.6

让我们试试原子类AtomicLong

//记录实际累加的数量
private static AtomicLong successNum = new AtomicLong(0);

/**
 * 原子类 AtomicLong
 *
 * @return
 */
@Override
public R factor6() {
    if ((successNum.incrementAndGet() % 10) == 0) {
        my++;
        return R("malu" + my);
    } else {
        return R("error");
    }
}

TPS: 20164.14 19359.96 19009.24

返回结果(线程安全):

第一次 第二次 第三次
malu100001 malu100001 malu100001

eg.7

来看JDK8里的LongAdder

private static LongAdder longAdder = new LongAdder();

/**
 * LongAdder
 *
 * @return
 */
@Override
public R factor7() {
    longAdder.increment();
    if ((longAdder.sum() % 10) == 0) {
        my++;
        return R("malu" + my);
    } else {
        return R("error");
    }
}

TPS: 18867.57 18704.17 20490.54

返回结果(没有锁,这样使用线程不安全):

第一次 第二次 第三次
malu99766 malu99868 malu99664

zookeeper分布式锁

互斥锁(排他锁)

ZkConfig.java

/**
 * 类说明: zookeeper配置
 *
 * @author : Malu
 * @Since : 2020-07-30 15:15
 **/
@Configuration
public class ZkConfig {
    @Bean(initMethod = "start")
    public CuratorFramework curatorFramework() {
        return CuratorFrameworkFactory.newClient(
                "192.168.3.27:2181",
                5000,
                5000,
                new RetryNTimes(5, 5000));
    }
}

ZkController.java

@Autowired
private CuratorFramework curatorFramework;

/**
 * zookeeper互斥锁(排他锁),高并发测试
 *
 * @return R
 */
@GetMapping("/mutex2")
public R getMutex2() throws Exception {
    // 获取一个分布式互斥锁
    InterProcessMutex lock = new InterProcessMutex(curatorFramework, "/mutex_lock2");
    try {
        // 开启两个进程测试,会发现:如果一个分布式互斥锁获取了锁,那么直到锁释放为止数据都不会被侵扰
        lock.acquire();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 在finally中释放,防止死锁
        lock.release();
    }
    return R();
}

环境:

CPU: i5 4590 @ 3.30 Ghz
内存: 32G
JDK: 1.8
测试工具:Jmeter
负载:200线程  ramp-up 5秒 10000循环次数

Windows10 本机zookeeper

TPS: 755.19

redisson分布式锁

pom.xml

<!-- https://mvnrepository.com/artifact/org.redisson/redisson-spring-boot-starter -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.13.3</version>
</dependency>

application.yml

spring:
  redis:
    host: 192.168.1.47
    port: 6381
    database: 15
    timeout: 10000

注意:Redis密码为空时不要加password参数,spring-boot自动装配会报错。

redissonController.java

@Autowired
private RedissonClient redissonClient;

@RequestMapping("lock2")
public R lock2() {
    RLock lock = redissonClient.getLock("redisson_lock2");
    lock.lock();
    lock.unlock();
    return R();
}

环境:

CPU: i5 4590 @ 3.30 Ghz
内存: 32G
JDK: 1.8
测试工具:Jmeter
负载:200线程  ramp-up 5秒 10000循环次数

独立Linux Redis

TPS: 1594.7

参考

使用Redis搭建电商秒杀系统 https://tech.antfin.com/docs/2/63920

Redis高并发秒杀测试 https://github.com/14251104246/redis-demo