JMeter 做压测

 

一、使用配置1

 

 

每发一次请求后，思考一秒。

 

最终结果如下：

 

如果此时改小思考时间：

 

 此时的并发是2.

 

此时，如果将线程数修改为2，则：

 

 

并发为4.

 

此时再修改思考时间为100ms，10个线程：

 

 

 

 则并发差不多为100：

 

如果要达到上千并发，则修改思考时间为10ms，看看能否达到：

 

实际上只发出了5000个请求，按理说，10个线程、每10ms发一个请求，（10个线程*10s*1000ms/10ms），按理有10000个请求，但是没达到。

应该是因为线程没办法10s发出一个，因为99% line都是46ms了。

 

如果修改为50个线程，再看看：

 

 此时的并发依然只有500的样子。而90%、95%、99%线达到了数百ms。

 

去掉思考定时器后：

 

看来该接口的并发大概只能支撑这么多了。

 

去掉接口中的分布式锁后，再进行压测：

package com.ceiec.sys.mqservice.service.impl;

import com.ceiec.sys.mqservice.controller.TestController;
import com.ceiec.sys.mqservice.service.SecondKillService;
import com.ceiec.sys.mqservice.utils.GUID;
import com.ceiec.sys.mqservice.vo.SuccessSecondKillUser;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

/**
 * desc:
 *
 * @author : caokunliang
 * creat_date: 2019/7/9 0009
 * creat_time: 19:34
 **/
@Service
public class SecondKillServiceImpl implements SecondKillService {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    private static final Logger logger = LoggerFactory.getLogger(SecondKillServiceImpl.class);

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String SECOND_KILL_KEY = "phone";
    @Autowired
    private RedissonClient redissonClient;

    public static final String REDISSON_DISTRIBUTE_KEY="cache.redisson.distribute.lock";

    @Override
    public void secondKill(String userId) {
49 //        RLock lock = redissonClient.getLock(REDISSON_DISTRIBUTE_KEY);

        try {
52 //            lock.lock();
            //去redis 的队列取
            ListOperations<String, Object> opsForList = redisTemplate.opsForList();
            String phone = (String)opsForList.leftPop(SECOND_KILL_KEY);
            if (phone == null) {
                logger.error("{} got phone failed.",userId);
                return;
            }

            String exchange = "exchange.010";
            String routingKey = "success-kill";

            SuccessSecondKillUser user = new SuccessSecondKillUser();
            user.setUserId(userId);
            user.setProductId(phone);

            CorrelationData data = new CorrelationData(phone);
            try {
                //mq消息发送方法
                rabbitTemplate.convertAndSend(exchange, routingKey, OBJECT_MAPPER.writeValueAsBytes(user), new MessagePostProcessor() {
                    //设置消息唯一ID
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                        message.getMessageProperties().setMessageId(GUID.generate());
                        return message;
                    }
                },data);
            }catch (Exception e){
                logger.error("e:{}",e);
                opsForList.leftPush(SECOND_KILL_KEY,phone);
            }
        }catch (Exception e){
            logger.error("{}",e);
        }finally {
//            lock.unlock();
        }


    }

    @Override
    public void init(){
        ListOperations<String, Object> opsForList = redisTemplate.opsForList();
        for (int i = 0; i < 100; i++) {
            opsForList.leftPush(SECOND_KILL_KEY,"手机00" + i);
        }
    }
}

 

 

这下，接口的并发，达到了4000。看来分布式锁还是挺耗时的