慕课网《Java高并发秒杀API之高并发优化》学习总结
时间：2017年08月25日星期五
说明：本文部分内容均来自慕课网。@慕课网：http://www.imooc.com
教学源码：无
学习源码：https://github.com/zccodere/study-imooc学习本门课程前请先学习前置课程《Java高并发秒杀API之业务分析与DAO层》和《Java高并发秒杀API之Service层》和《Java高并发秒杀API之web层》
首先搞清楚高并发发生在哪？
详情页
CDN的理解
CDN（内容分发网络）加速用户获取数据的系统
部署在离用户最近的网络节点上
命中CDN不需要访问后端服务器
互联网公司自己搭建或租用秒杀地址接口分析
无法使用CDN缓存
适合服务端缓存redis等
一致性维护成本低秒杀地址接口优化
秒杀操作优化分析
无法使用CDN缓存
后端缓存困难：库存问题
一行数据竞争：热点商品秒杀其他方案分析
成本分析
运维成本和稳定性：NoSQL、MQ等
开发成本：数据一致性、回滚方案等
幂等性难保证：重复秒杀问题
不适合新手的架构Java控制事务行为分析
瓶颈分析
优化分析
行级锁在Commit之后释放
优化方向减少行级锁持有时间如何判断Update更新库存成功
两个条件
Update自身没报错
客户端确认Update影响记录数
优化思路
把客户端逻辑放到MySQL服务端，避免网络延迟和GC影响如何放到MySQL服务端：两种解决方案
定制SQL方案：update /*+[auto_commit]*/,需要修改MySQL源码
使用存储过程：整个事务在MySQL端完成优化总结
前端控制：暴露接口，按钮防重复
动静态数据分离：CDN缓存，后端缓存
事务竞争优化：减少事务锁时间代码编写
1.编写RedisDao类
package com.myimooc.seckill.dao.cache;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import com.myimooc.seckill.entity.Seckill;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
/**
* @describe Redis数据访问对象
* @author zc
* @version 1.0 2017-08-26
*/
public class RedisDao {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
private final JedisPool jedisPool;
public RedisDao(String ip,int port){
jedisPool = new JedisPool(ip,port);
}
private RuntimeSchema<Seckill> schema = RuntimeSchema.createFrom(Seckill.class);
public Seckill getSeckill(long seckillId){
// redis操作逻辑
try {
Jedis jedis = jedisPool.getResource();
try{
String key = "seckill:"+seckillId;
// 并没有实现内部序列化操作
// get->byte[] ->反序列化 ->Object(Seckill)
// 采用自定义序列化
// protostuff ： pojo
byte[] bytes = jedis.get(key.getBytes());
// 缓存中获取到
if(bytes != null){
Seckill seckill = schema.newMessage();
ProtostuffIOUtil.mergeFrom(bytes,seckill,schema);
// seckill 被反序列
return seckill;
}
}finally {
jedis.close();
}
} catch (Exception e){
logger.error(e.getMessage(),e);
}
return null;
}
public String putSeckill(Seckill seckill){
// set Object(Seckill) -> 序列化 ->byte[]
try {
Jedis jedis = jedisPool.getResource();
try{
String key = "seckill:"+seckill.getSeckillId();
byte[] bytes = ProtostuffIOUtil.toByteArray(seckill,schema,
LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
// 超时缓存
int timeout = 60 * 60;// 1小时
String result = jedis.setex(key.getBytes(),timeout,bytes);
return result;
}finally {
jedis.close();
}
} catch (Exception e){
logger.error(e.getMessage(),e);
}
return null;
}
}
2.修改SeckillServiceImpl类 输出秒杀接口地址方法
/**
* 秒杀开启时输出秒杀接口地址，否则输出系统时间和秒杀时间
*
* @param seckillId
*/
public Exposer exportSeckillUrl(long seckillId) {
// 优化点：缓存优化：超时的基础上维护一致性
//1：访问redis
Seckill seckill = redisDao.getSeckill(seckillId);
if(null == seckill){
//2：访问数据库
seckill = seckillDao.queryById(seckillId);
if(null == seckill){
return new Exposer(false,seckillId);
}else {
//3：放入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 = this.getMD5(seckillId);
return new Exposer(true,md5,seckillId);
}回顾事务执行
简单优化
事务SQL在MySQL端执行（存储过程）
1.编写存储过程
-- 秒杀执行存储过程
DELIMITER $$ -- console ; 转换为 $$
-- 定义存储过程
-- 参数：in 输入参数；out 输出参数
-- row_count()：返回上一条修改类型sql的影响行数
-- row_count()：0 未修改数据；>0 修改的行数；<0 sql错误或未执行修改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(1003,13521542111,new(),@r_result);
select @r_result
-- 存储过程
-- 1：存储过程优化：事务行级锁持有的时间
-- 2：不要过度依赖存储过程
-- 3：简单的逻辑，可以应用存储过程
-- 4：QPS：一个秒杀单6000/qps
2.修改SeckillDao.xml
<!-- mybatis调用存存储过程 -->
<select id="killByProcedure" statementType="CALLABLE">
call execute_seckill(
#{seckillId,jdbcType=BIGINT,mode=IN},
#{phone,jdbcType=BIGINT,mode=IN},
#{killTime,jdbcType=TIMESTAMP,mode=IN},
#{result,jdbcType=INTEGER,mode=OUT}
)
</select>3.修改SeckillServiceImpl类
/**
* 执行秒杀操作，存储过程
*
* @param seckillId
* @param userPhone
* @param md5
*/
public SeckillExecution executeSeckillProcedure(long seckillId, long userPhone, String md5){
if(md5 == null || !md5.equals(getMD5(seckillId))){
return new SeckillExecution(seckillId,SeckillStatEnum.DATA_REWRITE);
}
Date killTime = new Date();
Map<String,Object> map = new HashMap<String, Object>();
map.put("seckillId",seckillId);
map.put("phone",userPhone);
map.put("killTime",killTime);
map.put("result",null);
// 执行存储过程，result被赋值
try {
seckillDao.killByProcedure(map);
// 获取result
int result = MapUtils.getInteger(map,"result",-2);
if(result == 1){
SuccessSeckilled sk = successKilledDao.queryByIdWithSeckill(seckillId,userPhone);
return new SeckillExecution(seckillId,SeckillStatEnum.SUCCESS,sk);
}else{
return new SeckillExecution(seckillId,SeckillStatEnum.stateOf(result));
}
}catch (Exception e){
logger.error(e.getMessage(),e);
return new SeckillExecution(seckillId,SeckillStatEnum.INNER_ERROR);
}
}系统可能用到哪些服务
CDN（内容分发网络）
WebServer：Nginx+Jetty
Redis：服务器端缓存
MySQL：数据存储服务大型系统部署架构
可能参与的角色
开发：前端+后端
测试
DBA
运维数据层技术回顾
数据库设计和实现
MyBatis理解和使用技巧
MyBatis整合Spring技巧业务层技术回顾
业务接口设计和封装
SpringIOC配置技巧
Spring声明式事务使用和理解WEB层技术回顾
Restful接口运用
SpringMVC使用技巧
前端交互分析过程
Bootstrap和js使用并发优化
系统瓶颈点分析
事务、锁、网络延迟理解
前端CDN、缓存等理解使用
集群化部署