SpringBoot集成redisson分布式锁

原文链接:https://blog.csdn.net/sinat_25295611/article/details/80420086

https://www.cnblogs.com/yangzhilong/p/7605807.html

业务场景：在电商项目中，往往会有这样的一个功能设计，当用户下单后一段时间没有付款，系统就会在超时后关闭该订单。

通常我们会做一个定时任务每分钟来检查前半小时的订单，将没有付款的订单列表查询出来，然后对订单中的商品进行库存的恢复，然后将该订单设置为无效。

比如我们这里使用Spring Schedule的方式做一个定时任务：

注：打开Spring Schedule 的自动注解扫描,在Spring配置中添加<task:annotation-driven/>

@Component
@Slf4j
public class CloseOrderTask {

    @Autowired
    private IOrderService iOrderService;

    @Scheduled(cron = "0 */1 * * * ? ")
    public void closeOrderTaskV1() {
        log.info("定时任务启动");
        //执行关闭订单的操作
        iOrderService.closeOrder();
        log.info("定时任务结束");
    }
}

在单服务器下这样执行并没有问题，但是随着业务量的增多，势必会演进成集群模式，在同一时刻有多个服务执行一个定时任务就会带来问题，首先是服务器资源的浪费，同时会带来业务逻辑的混乱，如果定时任务是做的数据库操作将会带来很大的风险。

Redis分布式锁

下面分析一下分布式情况下定时任务的解决方案

通常使用Redis作为分布式锁来解决这类问题，Redis分布式锁流程如下：

Redis分布式锁v1版本：

//注意：以下为了测试方便，定时时间都设置为10s
@Scheduled(cron = "0/10 * * * * ? ")
    public void closeOrderTaskV1() {
        log.info("定时任务启动");
        long lockTime = 5000;//5秒
        Long lockKeyResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis() + lockTime));

        //如果获得了分布式锁，执行关单业务
        if (lockKeyResult != null && lockKeyResult.intValue() == 1) {
            closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }else {
            log.info("没有获得分布式锁");
        }
        log.info("定时任务结束================================");
    }

//关闭订单，并释放锁
    private void closeOrder(String lockName) {
        RedisShardedPoolUtil.expire(lockName,50); //锁住50秒
        log.info("线程{} 获取锁 {}",Thread.currentThread().getName(),lockName);

        //模拟执行关单操作
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //主动关闭锁
        RedisShardedPoolUtil.del(lockName);
        log.info("线程{} 释放锁 {}",Thread.currentThread().getName(),lockName);
    }

(由于我电脑配置比较低，开2个IDEA进程调试会比较卡，所以一个项目在IDEA调试，另外一个打成war放在tomcat运行，打包命令mvn clean package -Dmaven.test.skip=true -Pdev)

tomcat1调试日志

tomcat2日志

此时分布式锁已经生效，在集群环境下不会同时出现2个任务同时执行的情况，但是这时又引出了另外一个问题，

我们的逻辑是先setnx获取分布式锁（此时该锁没有设置过期时间，即不会过期）,然后expire设置过期锁过期时间，如果在获取锁和设置过期时间之间，服务器（tomcat）挂了就会出现锁永远都不会过期的情况！

• 在正常关闭tomcat的情况下（shutdown），我们可以通过@PreDestory执行删除锁逻辑，如下

@PreDestroy
    public void delCloseLock(){
        RedisShardedPoolUtil.del(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        log.info("Tomcat shut down 释放锁 {}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
    }

• 在tomcat被kill或意外终止时，以上方法并不管用

  Redis分布式锁v2版本 :

  

  我们将setnx未获取到锁的情况进行重新设计，为的是防止v1版本死锁的产生，当第一次未获取到锁时，取出lockKey中存放的过期时间，与当前时间进行对比，若已超时则通过getset操作重置获取锁并更新过期时间，若第一次取出时未达到过期时间，说明还在上次任务执行的有效时间范围内，可能就需要等这一段时间，通常过期时间设置为2~5秒，不会太长。

以上则是在超时的基础上防止死锁的产生，以下为代码实现：

//注意：以下为了测试方便，定时时间都设置为10s

@Scheduled(cron = "0/10 * * * * ? ")
    public void closeOrderTaskV2() {
        log.info("定时任务启动");
        long lockTime = 5000; //5s
        Long lockKeyResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis() + lockTime));

        //如果获得了分布式锁，执行关单业务
        if (lockKeyResult != null && lockKeyResult.intValue() == 1) {
            closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }else {
            String lockValue1 = RedisShardedPoolUtil.get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            //查到锁的值并与当前时间比较检查其是否已经超时，若超时则可以重新获取锁
            if (lockValue1 != null && System.currentTimeMillis() > Long.valueOf(lockValue1)) {

                //通过用当前时间戳getset操作会给对应的key设置新的值并返回旧值，这是一个原子操作
                //redis返回nil,则说明该值已经无效
                String lockValue2 = RedisShardedPoolUtil.getSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis() + lockTime));

                if (lockValue2 == null || StringUtils.equals(lockValue1, lockValue2)) {
                    //获取锁成功
                    closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                } else {
                    log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
                }
            }

            log.info("没有获得分布式锁:{}",Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }
        log.info("定时任务结束================================");
    } 

至此，我们的这个分布式锁是没有问题了。

下面介绍一下使用Redisson这个框架来实现分布式锁。

Redisson实现分布式锁

Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid） ,其功能十分强大，解决很多分布式架构中的问题，附上其GitHub的WIKI地址：https://github.com/redisson/redisson/wiki

官方文档：https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95

增加tryLock方法，建议后面去掉DistributedLocker接口和其实现类，直接在RedissLockUtil中注入RedissonClient实现类（简单但会丢失接口带来的灵活性）。

1、引用redisson的pom

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.5.0</version>
</dependency>

2、定义Lock的接口定义类

import java.util.concurrent.TimeUnit;

import org.redisson.api.RLock;

public interface DistributedLocker {

    RLock lock(String lockKey);

    RLock lock(String lockKey, int timeout);

    RLock lock(String lockKey, TimeUnit unit, int timeout);

    boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime);

    void unlock(String lockKey);

    void unlock(RLock lock);
}

3、Lock接口实现类

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

import java.util.concurrent.TimeUnit;

public class RedissonDistributedLocker implements DistributedLocker {
    
    private RedissonClient redissonClient;

    @Override
    public RLock lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
        return lock;
    }

    @Override
    public RLock lock(String lockKey, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
        return lock;
    }
    
    @Override
    public RLock lock(String lockKey, TimeUnit unit ,int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
        return lock;
    }
    
    @Override
    public boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }
    
    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }
    
    @Override
    public void unlock(RLock lock) {
        lock.unlock();
    }

    public void setRedissonClient(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }
}

4、redisson属性装配类

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "redisson")
@ConditionalOnProperty("redisson.password")
public class RedissonProperties {

    private int timeout = 3000;

    private String address;

    private String password;
    
    private int database = 0;

    private int connectionPoolSize = 64;
    
    private int connectionMinimumIdleSize=10;

    private int slaveConnectionPoolSize = 250;

    private int masterConnectionPoolSize = 250;

    private String[] sentinelAddresses;

    private String masterName;

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public int getSlaveConnectionPoolSize() {
        return slaveConnectionPoolSize;
    }

    public void setSlaveConnectionPoolSize(int slaveConnectionPoolSize) {
        this.slaveConnectionPoolSize = slaveConnectionPoolSize;
    }

    public int getMasterConnectionPoolSize() {
        return masterConnectionPoolSize;
    }

    public void setMasterConnectionPoolSize(int masterConnectionPoolSize) {
        this.masterConnectionPoolSize = masterConnectionPoolSize;
    }

    public String[] getSentinelAddresses() {
        return sentinelAddresses;
    }

    public void setSentinelAddresses(String sentinelAddresses) {
        this.sentinelAddresses = sentinelAddresses.split(",");
    }

    public String getMasterName() {
        return masterName;
    }

    public void setMasterName(String masterName) {
        this.masterName = masterName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getConnectionPoolSize() {
        return connectionPoolSize;
    }

    public void setConnectionPoolSize(int connectionPoolSize) {
        this.connectionPoolSize = connectionPoolSize;
    }

    public int getConnectionMinimumIdleSize() {
        return connectionMinimumIdleSize;
    }

    public void setConnectionMinimumIdleSize(int connectionMinimumIdleSize) {
        this.connectionMinimumIdleSize = connectionMinimumIdleSize;
    }

    public int getDatabase() {
        return database;
    }

    public void setDatabase(int database) {
        this.database = database;
    }

    public void setSentinelAddresses(String[] sentinelAddresses) {
        this.sentinelAddresses = sentinelAddresses;
    }
}

5、SpringBoot自动装配类

import org.apache.commons.lang3.StringUtils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SentinelServersConfig;
import org.redisson.config.SingleServerConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.longge.lock.DistributedLocker;
import com.longge.lock.RedissonDistributedLocker;
import com.longge.lock.RedissonProperties;
import com.longge.utils.RedissLockUtil;

@Configuration
@ConditionalOnClass(Config.class)
@EnableConfigurationProperties(RedissonProperties.class)
public class RedissonAutoConfiguration {

    @Autowired
    private RedissonProperties redssionProperties;

    /**
     * 哨兵模式自动装配
     * @return
     */
    @Bean
    @ConditionalOnProperty(name="redisson.master-name")
    RedissonClient redissonSentinel() {
        Config config = new Config();
        SentinelServersConfig serverConfig = config.useSentinelServers().addSentinelAddress(redssionProperties.getSentinelAddresses())
                .setMasterName(redssionProperties.getMasterName())
                .setTimeout(redssionProperties.getTimeout())
                .setMasterConnectionPoolSize(redssionProperties.getMasterConnectionPoolSize())
                .setSlaveConnectionPoolSize(redssionProperties.getSlaveConnectionPoolSize());
        
        if(StringUtils.isNotBlank(redssionProperties.getPassword())) {
            serverConfig.setPassword(redssionProperties.getPassword());
        }
        return Redisson.create(config);
    }

    /**
     * 单机模式自动装配
     * @return
     */
    @Bean
    @ConditionalOnProperty(name="redisson.address")
    RedissonClient redissonSingle() {
        Config config = new Config();
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(redssionProperties.getAddress())
                .setTimeout(redssionProperties.getTimeout())
                .setConnectionPoolSize(redssionProperties.getConnectionPoolSize())
                .setConnectionMinimumIdleSize(redssionProperties.getConnectionMinimumIdleSize());
        
        if(StringUtils.isNotBlank(redssionProperties.getPassword())) {
            serverConfig.setPassword(redssionProperties.getPassword());
        }

        return Redisson.create(config);
    }

    /**
     * 装配locker类，并将实例注入到RedissLockUtil中
     * @return
     */
    @Bean
    DistributedLocker distributedLocker(RedissonClient redissonClient) {
        DistributedLocker locker = new RedissonDistributedLocker();
        locker.setRedissonClient(redissonClient);
        RedissLockUtil.setLocker(locker);
        return locker;
    }

}

6、Lock帮助类

import java.util.concurrent.TimeUnit;

import org.redisson.api.RLock;

import DistributedLocker;

/**
 * redis分布式锁帮助类
 * @author yangzhilong
 *
 */
public class RedissLockUtil {
    private static DistributedLocker redissLock;
    
    public static void setLocker(DistributedLocker locker) {
        redissLock = locker;
    }
    
    /**
     * 加锁
     * @param lockKey
     * @return
     */
    public static RLock lock(String lockKey) {
        return redissLock.lock(lockKey);
    }

    /**
     * 释放锁
     * @param lockKey
     */
    public static void unlock(String lockKey) {
        redissLock.unlock(lockKey);
    }
    
    /**
     * 释放锁
     * @param lock
     */
    public static void unlock(RLock lock) {
        redissLock.unlock(lock);
    }

    /**
     * 带超时的锁
     * @param lockKey
     * @param timeout 超时时间   单位：秒
     */
    public static RLock lock(String lockKey, int timeout) {
        return redissLock.lock(lockKey, timeout);
    }
    
    /**
     * 带超时的锁
     * @param lockKey
     * @param unit 时间单位
     * @param timeout 超时时间
     */
    public static RLock lock(String lockKey, TimeUnit unit ,int timeout) {
        return redissLock.lock(lockKey, unit, timeout);
    }
    
    /**
     * 尝试获取锁
     * @param lockKey
     * @param waitTime 最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @return
     */
    public static boolean tryLock(String lockKey, int waitTime, int leaseTime) {
        return redissLock.tryLock(lockKey, TimeUnit.SECONDS, waitTime, leaseTime);
    }
    
    /**
     * 尝试获取锁
     * @param lockKey
     * @param unit 时间单位
     * @param waitTime 最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @return
     */
    public static boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
        return redissLock.tryLock(lockKey, unit, waitTime, leaseTime);
    }
}

属性文件实例：

1、单机模式

# redisson lock
redisson.address=redis://10.18.75.115:6379
redisson.password=

这里如果不加redis://前缀会报URI构建错误，

Caused by: java.net.URISyntaxException: Illegal character in scheme name at index 0

其次，在redis进行连接的时候如果不对密码进行空判断，会出现AUTH校验失败的情况。

Caused by: org.redisson.client.RedisException: ERR Client sent AUTH, but no password is set. channel

2、哨兵模式

redisson.master-name=mymaster
redisson.password=xxxx
redisson.sentinel-addresses=10.47.91.83:26379,10.47.91.83:26380,10.47.91.83:26381

更多的配置信息可以去官网查看

初始化完成之后就可以来写分布式锁了，使用完Redisson实现分布锁之后就会发现一切是那么的简便：

//使用Redisson实现分布式锁
@Scheduled(cron = "0/10 * * * * ? ")
    public void closeOrderTaskV3() {
        log.info("定时任务启动");
        RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        boolean getLock = false;
        try {
            //todo 若任务执行时间过短，则有可能在等锁的过程中2个服务任务都会获取到锁，这与实际需要的功能不一致，故需要将waitTime设置为0
            if (getLock = lock.tryLock(0, 5, TimeUnit.SECONDS)) {
                int hour = Integer.parseInt(PropertiesUtil.getProperty("close.redis.lock.time","2"));
                iOrderService.closeOrder(hour);
            } else {
                log.info("Redisson分布式锁没有获取到锁:{},ThreadName :{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
           log.error("Redisson 获取分布式锁异常",e);
        }finally {
            if (!getLock) {
                return;
            }
            lock.unlock();
            log.info("Redisson分布式锁释放锁:{},ThreadName :{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, Thread.currentThread().getName());
        }
    }

以上就是Redisson的分布式锁实现代码，下面来分析一下：

1.RLock lock = redissonManager.getRedisson().getLock(String lockName);

RLock继承自java.util.concurrent.locks.Lock，可以将其理解为一个重入锁，需要手动加锁和释放锁

来看它其中的一个方法：tryLock(long waitTime, long leaseTime, TimeUnit unit)

2.getLock = lock.tryLock(0, 5, TimeUnit.SECONDS)

通过tryLock()的参数可以看出，在获取该锁时如果被其他线程先拿到锁就会进入等待，等待waitTime时间，如果还没用机会获取到锁就放弃，返回false；若获得了锁，除非是调用unlock释放，那么会一直持有锁，直到超过leaseTime指定的时间。

以上就是Redisson实现分布式锁的核心方法，有人可能要问，那怎么确定拿的是同一把锁，分布式锁在哪？

这就是Redisson的强大之处，其底层还是使用的Redis来作分布式锁，在我们的RedissonManager中已经指定了Redis实例，Redisson会进行托管，其原理与我们手动实现Redis分布式锁类似。