基于redis的分布式锁实现方案--redisson

实例代码地址，请前往：https://gitee.com/GuoqingLee/distributed-seckill

redis官方文档地址，请前往：http://www.redis.cn/topics/distlock.html

前言

关于分布式锁的实现，目前主流方案有以下三类：

1、基于数据库的乐观锁；

2、基于redis实现的锁服务；

3、基于zookeeper的实现；

网上关于怎么实现redis的分布式锁，一搜一大把的文章，有写的比较好的，也有明显存在缺陷的，非常容易误导初入这一块的初学者；

而存在的问题，无外乎是setnx()-->expire()，保证不了原子性，容易出现死锁等情况，这里就不在去做解释了；

本文的主旨是如何使用redis官方推荐的redisson实现redis的分布式锁；

一、具体实现：

maven引入需要的jar

 <dependency>
     <groupId>org.redisson</groupId>
     <artifactId>redisson-spring-boot-starter</artifactId>
     <version>3.10.1</version>
 </dependency>

配置文件如下

# common spring boot settings

spring.redis.database=
spring.redis.host=
spring.redis.port=
spring.redis.password=
spring.redis.ssl=
spring.redis.timeout=
spring.redis.cluster.nodes=
spring.redis.sentinel.master=
spring.redis.sentinel.nodes=

封装工具类：

 package cn.com.bluemoon.redis.lock;

 import java.util.concurrent.TimeUnit;

 import org.redisson.api.RLock;
 import org.redisson.api.RedissonClient;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

 /**
  * 基于Redisson的分布式锁实现
  * @author Guoqing.Lee
  * @date 2019年1月23日 下午4:04:57
  *
  */
 @Component
 public class RedissonDistributedLocker {

     @Autowired
     private RedissonClient redissonClient;

     /**
      * 加锁
      * @param lockKey
      * @return
      */
     public RLock lock(String lockKey) {
         RLock lock = redissonClient.getLock(lockKey);
         lock.lock();
         return lock;
     }

     /**
      * 加锁，过期自动释放
      * @param lockKey
      * @param leaseTime    自动释放锁时间
      * @return
      */
     public RLock lock(String lockKey, long leaseTime) {
         RLock lock = redissonClient.getLock(lockKey);
         lock.lock(leaseTime, TimeUnit.SECONDS);
         return lock;
     }

     /**
      * 加锁，过期自动释放，时间单位传入
      * @param lockKey
      * @param unit        时间单位
      * @param leaseTime    上锁后自动释放时间
      * @return
      */
     public RLock lock(String lockKey, TimeUnit unit, long leaseTime) {
         RLock lock = redissonClient.getLock(lockKey);
         lock.lock(leaseTime, unit);
         return lock;
     }

     /**
      * 尝试获取所
      * @param lockKey
      * @param unit        时间单位
      * @param waitTime    最多等待时间
      * @param leaseTime    上锁后自动释放时间
      * @return
      */
     public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) {
         RLock lock = redissonClient.getLock(lockKey);
         try {
             return lock.tryLock(waitTime, leaseTime, unit);
         } catch (InterruptedException e) {
             return false;
         }
     }

     /**
      * 尝试获取所
      * @param lockKey
      * @param waitTime    最多等待时间
      * @param leaseTime    上锁后自动释放锁时间
      * @return
      */
     public boolean tryLock(String lockKey, long waitTime, long leaseTime) {
         RLock lock = redissonClient.getLock(lockKey);
         try {
             return lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
         } catch (InterruptedException e) {
             return false;
         }
     }

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

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

 }

二、使用方式

方式一：

     @Autowired
     private RedissonDistributedLocker redissonDistributedLocker;

         String lockKey = "BM_MARKET_SECKILL_" + stallActivityId;
     try {
                 //超过2S自动释放锁
         redissonDistributedLocker.lock(lockKey, 2L);
                 //业务处理

         } finally {
         redissonDistributedLocker.unlock(lockKey);  //释放锁
     }    

方案二：

 @Autowired
 private RedissonDistributedLocker redissonDistributedLocker;

 public void test() throws InterruptedException {
     final int[] counter = {0};

         for (int i= 0; i < 100; i++){

             new Thread(new Runnable() {

                 @Override

                 public void run() {
                     boolean isGetLock = redissonDistributedLocker.tryLock("test0001", 3L, 1L);
                     if(isGetLock) {
                         try {
                             int a = counter[0];
                             counter[0] = a + 1;
                             logger.info(a + "");
                         } finally {
                             redissonDistributedLocker.unlock("test0001");
                         }
                     }
                 }
             }).start();

         }

         // 主线程休眠，等待结果
         Thread.sleep(5000);
         System.out.println(counter[0]);
         logger.info(counter[0] + "");
 }

闲话就不多说了，希望能对你有所帮助。