SpringMVC+Redis实现分布式锁实现秒杀功能
1.实现分布式锁的几种方案
1.Redis实现 (推荐)
2.Zookeeper实现
3.数据库实现
Redis实现分布式锁
*
* 在集群等多服务器中经常使用到同步处理一下业务，这是普通的事务是满足不了业务需求，需要分布式锁
*
* 分布式锁的常用3种实现：
* 0.数据库乐观锁实现
* 1.Redis实现 — 使用redis的setnx()、get()、getset()方法，用于分布式锁，解决死锁问题
* 2.Zookeeper实现
* 参考：http://surlymo.iteye.com/blog/2082684
* http://www.jb51.net/article/103617.htm
* http://www.hollischuang.com/archives/1716?utm_source=tuicool&utm_medium=referral
* 1、实现原理：
基于zookeeper瞬时有序节点实现的分布式锁，其主要逻辑如下（该图来自于IBM网站）。大致思想即为：每个客户端对某个功能加锁时，在zookeeper上的与该功能对应的指定节点的目录下，生成一个唯一的瞬时有序节点。判断是否获取锁的方式很简单，只需要判断有序节点中序号最小的一个。当释放锁的时候，只需将这个瞬时节点删除即可。同时，其可以避免服务宕机导致的锁无法释放，而产生的死锁问题。
2、优点
锁安全性高，zk可持久化
3、缺点
性能开销比较高。因为其需要动态产生、销毁瞬时节点来实现锁功能。
4、实现
可以直接采用zookeeper第三方库curator即可方便地实现分布式锁
*
* Redis实现分布式锁的原理：
* 1.通过setnx(lock_timeout)实现，如果设置了锁返回1， 已经有值没有设置成功返回0
* 2.死锁问题：通过实践来判断是否过期，如果已经过期，获取到过期时间get(lockKey)，然后getset(lock_timeout)判断是否和get相同，
* 相同则证明已经加锁成功，因为可能导致多线程同时执行getset(lock_timeout)方法，这可能导致多线程都只需getset后，对于判断加锁成功的线程，
* 再加expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS)过期时间，防止多个线程同时叠加时间，导致锁时效时间翻倍
* 3.针对集群服务器时间不一致问题，可以调用redis的time()获取当前时间
2.Redis分分布式锁的代码实现
1.定义锁接口
/**
* @Description: Redis分布式锁接口
* @Author: fxb
* @CreateDate: 2018/3/29 15:43
* @Version: 1.0
*/
public interface RedisLockService {
/**
* 加锁成功，返回加锁时间
* @param lockKey
* @param threadName
* @return
*/
public Long lock(String lockKey);
/**
* 解锁， 需要更新加锁时间，判断是否有权限
* @param lockKey
* @param lockValue
* @param threadName
*/
public void unlock(String lockKey, long lockValue);
/**
* 多服务器集群，使用下面的方法，代替System.currentTimeMillis()，获取redis时间，避免多服务的时间不一致问题！！！
* @return
*/
public long currtTimeForRedis();
}2、实现锁实现
package com.jason.mrht.service.websrv.impl;
import com.jason.mrht.service.websrv.RedisLockService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
/**
* @author fxb
* @date 2018/3/29 15:43
*/
@Service
public class RedisLockServiceImpl extends BaseWebSrvService implements RedisLockService {
/**
* 加锁超时时间，单位毫秒， 即：加锁时间内执行完操作，如果未完成会有并发现象
*/
private static final long LOCK_TIMEOUT = 5 * 1000;
private static final Logger LOG = LoggerFactory.getLogger(RedisLockServiceImpl.class);
/**
* 取到锁加锁 取不到锁一直等待直到获得锁
*/
@Override
public Long lock(final String lockKey) {
LOG.info("开始执行加锁");
//循环获取锁
while (true) {
//锁时间
final Long lock_timeout = System.currentTimeMillis() + LOCK_TIMEOUT + 1;
if (otherCache.execute(new RedisCallback() {
@Override
public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer();
byte[] value = jdkSerializer.serialize(lock_timeout);
return connection.setNX(lockKey.getBytes(), value);
}
})) {
//如果加锁成功
LOG.info("加锁成功++++++++111111111");
//设置超时时间，释放内存
otherCache.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS);
return lock_timeout;
} else {
// redis里的时间
Long currt_lock_timeout_Str = (Long) otherCache.opsForValue().get(lockKey);
//锁已经失效
if (currt_lock_timeout_Str != null && currt_lock_timeout_Str < System.currentTimeMillis()) {
// 判断是否为空，不为空的情况下，说明已经失效，如果被其他线程设置了值，则第二个条件判断是无法执行
Long old_lock_timeout_Str = (Long) otherCache.opsForValue().getAndSet(lockKey, lock_timeout);
// 获取上一个锁到期时间，并设置现在的锁到期时间
if (old_lock_timeout_Str != null && old_lock_timeout_Str.equals(currt_lock_timeout_Str)) {
// 如过这个时候，多个线程恰好都到了这里，但是只有一个线程的设置值和当前值相同，他才有权利获取锁
LOG.info("加锁成功+++++++2222222222");
//设置超时时间，释放内存
otherCache.expire(lockKey, LOCK_TIMEOUT, TimeUnit.MILLISECONDS);
//返回加锁时间
return lock_timeout;
}
}
}
try {
LOG.info("等待加锁，睡眠100毫秒");
//睡眠100毫秒
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void unlock(String lockKey, long lockvalue) {
//正常直接删除 如果异常关闭判断加锁会判断过期时间
LOG.info("执行解锁==========");
// redis里的时间
Long currt_lock_timeout_Str = (Long) otherCache.opsForValue().get(lockKey);
//如果是加锁者 则删除锁 如果不是则等待自动过期 重新竞争加锁
if (currt_lock_timeout_Str != null && currt_lock_timeout_Str == lockvalue) {
//删除键
otherCache.delete(lockKey);
LOG.info("解锁成功-----------------");
}
}
/**
* 多服务器集群，使用下面的方法，代替System.currentTimeMillis()，获取redis时间，避免多服务的时间不一致问题！！！
*
* @return
*/
@Override
public long currtTimeForRedis() {
return otherCache.execute(new RedisCallback() {
@Override
public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
return redisConnection.time();
}
});
}
} 3.分布式锁验证
package com.jason.mrht.core.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* 测试模块
* @author bao
*/
@Controller
@RequestMapping("/api/redis")
public class TestController extends BaseController {
/**
* 秒杀商品数量10个
*/
private int goodNum = 10;
private static final String LOCK_NO = "redis_distribution_lock_no_";
private static int i = 0;
private int taskNum = 1000;
/**
* redis分布式锁测试
* 模拟1000个线程同时执行业务，修改资源
*/
@ResponseBody
@RequestMapping(value = "/redisLock", method = RequestMethod.GET)
public String testRedisDistributionLock1() {
/** task(); */
for (int i = 0; i < taskNum; i++) {
new Thread(new Runnable() {
@Override
public void run() {
task();
}
}).start();
}
return "OK";
}
/**
* 创建一个redis分布式锁任务
*/
private void task() {
//加锁时间
Long lockTime;
if ((lockTime = serviceTemplate.getRedisLockService().lock((LOCK_NO + 1) + "")) != null) {
//开始执行任务
logger.info("当前库存的数量："+goodNum);
if (goodNum == 0) {
logger.info("停止减库存任务");
} else {
goodNum--;
logger.info("开始减库存任务");
}
logger.info("任务执行中" + (i++));
// 任务执行完毕 关闭锁
serviceTemplate.getRedisLockService().unlock((LOCK_NO + 1) + "", lockTime);
}
}
}4.结果验证：
在Controller中模拟了1000个线程，通过线程池方式提交，每次20个线程抢占分布式锁，抢到分布式锁的执行代码，没抢到的等待
模拟秒杀10个商品1000个人来争夺
5、模拟用户的并发请求
package com.jason.mrht.common.utils;
/**
* @Description: 类作用描述
* @Author: fxb
* @CreateDate: 2018/3/29 18:55
* @Version: 1.0
*/
import com.jason.mrht.common.exception.HttpException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
/**
* 模拟用户的并发请求，检测用户乐观锁的性能问题
*
* @author zzg
* @date 2017-02-10
*/
public class ConcurrentTest {
final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public static void main(String[] args){
//模拟10000人并发请求，用户钱包
CountDownLatch latch=new CountDownLatch(1);
//模拟10000个用户
for(int i=0;i<10000;i++){
AnalogUser analogUser = new AnalogUser("user"+i,"58899dcd-46b0-4b16-82df-bdfd0d953bfb"+i,"1","20.024",latch);
analogUser.start();
}
//计数器減一 所有线程释放 并发访问。
latch.countDown();
System.out.println("所有模拟请求结束 at "+sdf.format(new Date()));
}
static class AnalogUser extends Thread{
//模拟用户姓名
String workerName;
String openId;
String openType;
String amount;
CountDownLatch latch;
public AnalogUser(String workerName, String openId, String openType, String amount,
CountDownLatch latch) {
super();
this.workerName = workerName;
this.openId = openId;
this.openType = openType;
this.amount = amount;
this.latch = latch;
}
@Override
public void run() {
// TODO Auto-generated method stub
try {
latch.await(); //一直阻塞当前线程，直到计时器的值为0
} catch (InterruptedException e) {
e.printStackTrace();
}
post();//发送post 请求
}
public void post(){
String result = "";
System.out.println("模拟用户： "+workerName+" 开始发送模拟请求 at "+sdf.format(new Date()));
try {
result = HttpUtil.sendGet("http://localhost:8080/api/collect/distribution/redis/lock1",null);
}catch (HttpException e){
}
//sendPost("http://localhost:8080/Settlement/wallet/walleroptimisticlock.action", "openId="+openId+"&openType="+openType+"&amount="+amount);
System.out.println("操作结果："+result);
System.out.println("模拟用户： "+workerName+" 模拟请求结束 at "+sdf.format(new Date()));
}
}
}