seckill项目创建流程---高并发优化

具体的一些修改细节,已经在前面三个部分有所体现:redis缓存,存储过程,修改关于行级锁的时间控制(先插入购买明细,然后再update库存)

1、需要优化的部分

seckill项目创建流程---高并发优化_第1张图片
image.png

详情页:

seckill项目创建流程---高并发优化_第2张图片
image.png

当秒杀即将开始时,用户会频繁的进行刷新操作,该操作会频繁的获取css,js等静态资源。 detail.jsp页面静态化,静态资源css,js等存放于CDN中(CDN:内容分发网络,用于加速用户获取数据的系统,部署在离用户最近的网络节点上,命中CDN后不需要再访问后端服务器)

系统时间:
不需要优化,因为获取系统时间访问一次内存(cacheline)大约为10ns,极短。

地址暴露接口:

seckill项目创建流程---高并发优化_第3张图片
image.png

无法使用CDN缓存:秒杀时间以及秒杀状态的变化
适合服务器缓存:redis等,当很多用户点击商品详情时,便可以不用每次都从数据库中提取数据,可以从缓存中获取数据

秒杀地址接口优化:

seckill项目创建流程---高并发优化_第4张图片
image.png

请求地址 --> (redis缓存 --> Mysql数据)
一致性维护:超时穿透/主动更新;
缓存超时或者缓存随着数据库主动更新
jedis api中存在设置缓存时限的方法

秒杀操作优化分析:

seckill项目创建流程---高并发优化_第5张图片
image.png

后端缓存问题:当多个用户同时命中redis缓存时,会产生库存问题,因此不能使用redis缓存。
一行数据竞争:对于热点商品,会有极多的用户对一行数据进行减库存或者update操作,在这当中就设计到了对于该行数据锁的时间控制问题

2、优化

~、地址暴露接口
采用redis缓存进行优化。
当用户点击商品详情后,经过seckill.js的一系列逻辑后,若符合秒杀情况则暴露秒杀地址。此操作详情为:
controller:

/**
     * 暴露秒杀的接口的方法
     *
     * @param seckillId
     * @return 根据用户秒杀的商品id进行业务逻辑判断,返回不同的json实体结果
     */
    @RequestMapping(value = "/{seckillId}/exposer", method = RequestMethod.POST)
    @ResponseBody // 告诉springmvc,返回的类型作为ajax输出
    public SeckillResult exposer(@PathVariable("seckillId") Long seckillId) {
        SeckillResult result;

        try {
            Exposer exposer = seckillService.exportSeckillUrl(seckillId);
            result = new SeckillResult(true, exposer);
        } catch (Exception e) {

//          logger.error(e.getMessage(), e);
            result = new SeckillResult(false, e.getMessage());
        }
        return result;
    }

seckillService.exportSeckillUrl(seckillId):(图中标明redis相关)

    /**
     * 暴露秒杀地址
     */
    public Exposer exportSeckillUrl(long seckillId) {
        //  Auto-generated method stub

        /*Seckill seckill = seckillDao.queryById(seckillId);
        if (seckill == null){
            return new Exposer(false,seckillId);
        }*/


        //此处使用到了redis相关
        Seckill seckill = redisDao.getSeckill(seckillId);
        if (seckill == null) {
            //访问数据库读取数据
            seckill = seckillDao.queryById(seckillId);
            if (seckill == null) {
                return new Exposer(false, seckillId);
            } else {
                //放入redis中
                redisDao.putSeckill(seckill);
            }
        }
        Date startTime = seckill.getStartTime();
        Date endTime = seckill.getEndTime();
        //当前系统时间
        Date nowTime = new Date();

        if (nowTime.getTime() < startTime.getTime()
                || nowTime.getTime() > endTime.getTime()) {
            return new Exposer(false, seckillId, nowTime.getTime(),
                    startTime.getTime(), endTime.getTime());
        }
        String md5 = getMD5(seckillId);//

        return new Exposer(true, md5, seckillId);
    }

redisDao:

com.seckill.dao.cache.RedisDao
/**
 * redis缓存数据的操作,set、get(序列化和反序列化)
 */
public class RedisDao {

    private final org.slf4j.Logger logger = LoggerFactory.getLogger(this.getClass());
    //用来实现连接redis客户端的池子
    private final JedisPool jedisPool;
    //通过对象的类构建对应的scheme
    private Schema schema = RuntimeSchema.createFrom(Seckill.class);
    //构造函数,用于spring的bean构造函数注入
    public RedisDao(String ip, int port) {
        jedisPool = new JedisPool(ip, port);
    }

    /**
     * 根据id,从redis中获取反序列化后的value数据
     * @param seckillId
     * @return
     */
    public Seckill getSeckill(long seckillId) {
        //redis操作业务逻辑
        //此处getResource和数据库连接池中类似,获取其中的一条连接
        try (Jedis jedis = jedisPool.getResource()) {
            String key = "seckill:" + seckillId;
            //并没有实现内部序列化操作
            //get -> byte[] 字节数组 ->反序列化 > Object(Seckill)
            //采用自定义的方式序列化
            //缓存获取到
            byte[] bytes = jedis.get(key.getBytes());
            if (bytes != null) {
                //字节数组不为空,创建一个可以用来存放反序列化的空对象
                Seckill seckill = schema.newMessage();
                //反序列化
                ProtostuffIOUtil.mergeFrom(bytes, seckill, schema);
                //seckill被反序列化
                return seckill;
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

    /**
     * 根据id,将以特定的key格式以及序列化后的value,存入redis中
     * @param seckill
     * @return
     */
    public String putSeckill(Seckill seckill) {
        //set Object(Seckill) ->序列化 -> byte{}
        Jedis jedis = jedisPool.getResource();
        String key = "seckill:" + seckill.getSeckillId();
        LinkedBuffer linkedBuffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        byte[] bytes = ProtostuffIOUtil.toByteArray(seckill, schema, linkedBuffer);
        //超时缓存
        int timeout = 60 * 60;
        return jedis.setex(key.getBytes(), timeout, bytes);
    }
}

注意上方的超时缓存,timeout!!!
~、秒杀操作优化
使用存储过程????
控制行级锁的时间

-- 秒杀执行存储过程
-- 分号转换
DELIMITER $$ -- console;转换为 $$
$$
-- 定义存储过程
-- 参数: in 参数  out 输出参数
-- row_count() 返回上一条修改类型sql(delete,insert,update)的影响行数
-- row_count: 0 :未修改数据;>0:表示修改的行数;<0:sql错误
CREATE PROCEDURE `seckill`.`execute_seckill`
  (
  IN v_seckill_id BIGINT, IN  v_phone BIGINT,
    IN v_kill_time TIMESTAMP,OUT r_result INT
  )
  BEGIN
    DECLARE insert_count INT DEFAULT 0;
    START TRANSACTION;
    INSERT IGNORE INTO success_killed
    (seckill_id, user_phone, create_time)
      VALUES (v_seckill_id, v_phone,v_kill_time);
    SELECT  row_count()
      INTO  insert_count;
    IF  (insert_count = 0)
      THEN ROLLBACK ;
        SET r_result = -1;
      ELSEIF (insert_count < 0)
        THEN ROLLBACK ;
      SET r_result = -2;
      ELSE
      UPDATE  seckill
        SET number = number -1
        WHERE seckill_id = v_seckill_id
        AND end_time > v_kill_time
        AND start_time < v_kill_time
        AND number > 0;
        SELECT row_count()
          INTO insert_count;
      IF (insert_count =  0)
        THEN ROLLBACK ;
        SET r_result = 0;
        ELSEIF (insert_count < 0)
          THEN ROLLBACK ;
        SET r_result = -2;
        ELSE COMMIT ;
        SET r_result = 1;
        END IF ;
      END IF ;
    END;
$$

-- 储存过程定义结束
DELIMITER ;
SET @r_result = - 3;
-- 执行存储过程
CALL `execute_seckill`(1001,18126745520,now(),@r_result);
-- 获取结果
SELECT @r_result;


-- 存储过程
-- 1:存储过程优化:事务行级锁持有的时间
-- 2:不要过度依赖存储过程
-- 3:简单的逻辑可以应用存储过程
-- 4:QPS:一个秒杀单6000/qps

你可能感兴趣的:(seckill项目创建流程---高并发优化)