上篇介绍了redis在集群环境下如何解决session共享的问题。今天来讲一下如何解决分布式锁的问题
什么是分布式锁？
分布式锁就是在多个服务器中，都来争夺某一资源。这时候我们肯定需要一把锁是不是 ，这个锁就是分布式锁，就算不是分布式，单机情况下，多个进程来争夺同一个资源，我们也要一把锁来控制先后顺序不是。分布式锁就是在多个服务器场景中来争夺相同的资源。打个比方，比如调度任务。
比如说，我们一个商城网站，要求每分钟要执行一个定时任务的操作，目的是把下单之后30分钟未付款的，把订单取消，然后把库存还原过去。因为是在多tomcat下，这个定时任务肯定会在同一时刻多个服务器都要执行操作。但是我们需要的是其中一个服务器操作就行了。这时候，就要用到我们的分布式锁啦。
我们在用redis来实现这个分布式锁的功能。我们会用到setnx方法，del方法，expire方法，getset方法 （这些方法的特性自己去百度下最好）
大致原理：我们利用setnx方法来设置一个key（写死的，以后都要用这个key获取锁），value的值（当前时间戳+锁的过期时间），如果设置成功返回1，说明我们已经获取锁，
然后再用expire方法设置key的有效期，因为肯定要有一个有效期的，不然你这一分钟已经执行完了，别人还想利用setnx获取锁，就一直获取不到，就造成了死锁。
设置好有效期之后，然后执行关单的业务逻辑，然后删除key。
其他服务器同时间操作，也是先setnx一下，结果发现别人已经获取到了锁，就返回失败0，然后就不执行关单操作。
上面的方法看似还可以，但是有一些bug，比如说服务器1setnx之后准备设置过期时间勒，服务器重启了，那是不是这个key就一直就消失不了了，那就造成了死锁。后面的永远都获取不到这个锁。细心的你肯定发现了，我们之前setnx的时候value还没用上呢？哈哈，现在就要用上了，我们来稍微改造一下。
我们之前的逻辑是如果获取锁，就执行设置过期时间，关单操作，没有获取锁就不执行关单操作。
我们现在改成如果没有获取锁，再进行一次判断，我们获取当前这个锁的value，因为key是我们写死的常量，我们可以从redis获取value时间戳
我们得到时间戳之后判断一下，这个时间戳和当前时间比那个大，如果当前时间大，说明这个锁已经过期了。因为我们上面已经说了，这个value的值就是当前时间+锁的过期时间
然后我们用getset方法重新设置锁的有效期，然后得到老得时间和再用单纯的get方法再获取老得时间，看是否相等，这点非常重要，因为相等说明中间没有其他线程获取到这个锁。可能有点迷，看代码就不迷了。ok 看代码吧
第一种会出现死锁的场景和第二种双重判断防止死锁的场景都有 注释很清楚
/**
* 可能出现死锁，虽然在执行close的时候有防死锁，但是还是会出现，继续演进V3
*/
// @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
public void closeOrderTaskV2() throws InterruptedException {
long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","5000"));//锁5秒有效期
//这个时间如何用呢，看下面。和时间戳结合起来用。
Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis()+lockTimeout));
if(setnxResult != null && setnxResult.intValue() == 1){
//如果返回值是1，代表设置成功，获取锁
closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
}else{
log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
}
} /**
* 防死锁之分布式锁
* @throws InterruptedException
*/
// @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
public void closeOrderTaskV3() throws InterruptedException {
//防死锁分布式锁
long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout","50000"));//锁50秒有效期
//项目由于历史数据关单订单比较多,需要处理,初次用50s时间,后续改成5s即可.同时50s也为了讲课debug的时候时间长而设置。
//大家可以根据实际情况，如果历史订单都处理完毕，或者在外部进行洗数据ok，这里的lock的时间应该设置小一些，例如1s 2s 3s 4s 5s就足够啦。 //这个时间如何用呢，看下面。和时间戳结合起来用。
Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis()+lockTimeout));
if(setnxResult != null && setnxResult.intValue() == 1){
//如果返回值是1，代表设置成功，获取锁
closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
}else{
//如果setnxResult==null 或 setnxResult.intValue() ==0 即 != 1的时候
//未获取到锁，继续判断,判断时间戳,看是否可以重置获取到锁
String lockValueStr = RedisShardedPoolUtil.get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK); //如果lockValue不是空,并且当前时间大于锁的有效期,说明之前的lock的时间已超时,执行getset命令.
if(lockValueStr != null && System.currentTimeMillis() > Long.parseLong(lockValueStr)){
String getSetResult = RedisShardedPoolUtil.getSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,String.valueOf(System.currentTimeMillis()+lockTimeout));
//再次用当前时间戳getset，
//返回给定 key 的旧值。 ->旧值判断，是否可以获取锁
// 当 key 没有旧值时，即 key 不存在时，返回 nil 。 ->获取锁
//这里我们set了一个新的value值，获取旧的值。
if(getSetResult == null || (getSetResult !=null && StringUtils.equals(lockValueStr,getSetResult))){
//获取到锁
closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
}else{
log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
}
}else{
log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
}
}
} /**
* Redisson分布式锁实现
* @throws InterruptedException
*/
// @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
public void closeOrderTaskV4() throws InterruptedException {
RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
boolean getLock = false;
try {
if(getLock = lock.tryLock(2,50, TimeUnit.SECONDS)){//trylock增加锁
log.info("===获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
iOrderService.closeOrder(hour);
}else{
log.info("===没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
}
}finally {
if(!getLock){
return;
}
log.info("===释放分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
lock.unlock();
}
} private void closeOrder(String lockName){
// expire命令用于给该锁设定一个过期时间，用于防止线程crash，导致锁一直有效，从而导致死锁。
RedisShardedPoolUtil.expire(lockName,50);//有效期50秒,防死锁
log.info("获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
iOrderService.closeOrder(hour);
RedisShardedPoolUtil.del(lockName);//释放锁
log.info("释放{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
log.info("=============================");
}
#2018-04-10 21:57:01 再来填坑
再解释一下上面的逻辑，注意：上面有两个时间，一个key的过期时间，一个锁的过期时间。都是为了避免死锁的发生。
为毛要设置两个呢？任意一个都可以避免死锁啊？因为当我们setnx的时候是不能设置过期时间的，如果刚好setnx之后突然断电还没来得及设置key的过期时间，那岂不是会发生死锁。所以我们要再来个锁的过期时间来进一步判断。最根本原因是得到锁和设置key的过期时间没有同步，下面介绍一个redis分布式锁的框架。轻松解决分布式锁的问题，原理和上面一样，不过代码更为简单。不用过多的判断，框架已经帮我们做好了。
注意：Redisson这个框架不支持分布式就是只能一个redis，但是支持主从模式。和spring的session框架一样。切记
pom.xml 这个是Redisson所需的依赖
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>2.9.0</version>
</dependency>
<!--com.fasterxml.jackson.dataformat.avro.PackageVersion-->
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-avro</artifactId>
<version>2.9.0</version>
</dependency>
RedissonManager.java
package com.mmall.common; import com.mmall.util.PropertiesUtil;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.config.Config;
import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; /**
* Created by geely
*/
@Slf4j
@Component
public class RedissonManager {
//在redis环境没有搭建起来之前，这里先注释上，否则项目启动不起来。 private Config config = new Config(); private Redisson redisson = null; private final static String redis1Ip = PropertiesUtil.getProperty("redis1.ip");
private final static Integer redis1Port = Integer.parseInt(PropertiesUtil.getProperty("redis1.port")); //注入到Spring容器的话，使用@PostConstruct或者静态块初始化，效果是一样的{} @PostConstruct
private void init() {
try {
//在redis环境没有搭建起来之前，这里先注释上，否则项目启动不起来。 ////127.0.0.1:6379
config.useSingleServer().setAddress(new StringBuilder().append(redis1Ip).append(":").append(redis1Port).toString()); //单主模式
// config.useMasterSlaveServers().setMasterAddress(new StringBuilder().append(redis1Ip).append(":").append(redis1Port).toString()); //主从模式
// config.useMasterSlaveServers().setMasterAddress("10.211.55.6:6379").addSlaveAddress("10.211.55.6:6380"); // redisson = (Redisson) Redisson.create(config);
log.info("初始化Redisson结束");
} catch (Exception e) {
log.error("redisson init error", e);
}
} // {
// init();
// } public Redisson getRedisson() {
return redisson;
} }
下面是具体实现代码，原理一样，只不过简化操作。切记：一定要把tryLock的第一个参数等待获取锁的时间设置为0.有坑
/**
* Redisson分布式锁实现
* @throws InterruptedException
*/
// @Scheduled(cron="0 */1 * * * ?")//每1分钟(每个1分钟的整数倍)
public void closeOrderTaskV4() throws InterruptedException {
//意思是把Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK这个常量当成key
RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
boolean getLock = false;
try {
if(getLock = lock.tryLock(2,50, TimeUnit.SECONDS)){//trylock试着获取锁，2的意思是等待获取锁的时间为2s，要设为0，不然会出现一些意想不到的错误，50的意思就是锁的过期时间(同样也是key的过期时间)
log.info("===获取{},ThreadName:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK,Thread.currentThread().getName());
int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour","2"));
iOrderService.closeOrder(hour);
}else{
log.info("===没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
}
}finally {
if(!getLock){
return;
}
log.info("===释放分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
lock.unlock();
}
}
ok，原生的方法有了，框架的也有了。点个赞吧。