• Redis分布式锁

    目录

     Redis分布式锁实现：

     1.首先是setnx命令实现分布式锁

     2.问题之设置过期时间防止别人拿不到锁）

    3.问题之设置uuid防止误删现象发生

    4.问题之最后判断+删除这里没有保证原子性： 

    5.问题之lock功能可重入的实现+重写加锁流程

     6.lua脚本重写解锁功能

    7.自定义分布式锁的构造+uuid识别

    所有代码 

    上锁lock()和解锁unlock()和ReentrantLock思路一致，逻辑给到我们自定义的DistributeRedisLock实现上锁和解锁逻辑

    1. public class ReentrantLock implements Lock, java.io.Serializable {
    2.     private static final long serialVersionUID = 7373984872572414699L;
    3.     /**提供所有实现机制的同步器
    4.     private final Sync sync;
    6.     /**
    7.      * 此锁的同步控制基础。下面分为公平和非公平版本。使用 AQS 状态来表示持有锁的次数。
    8.      */
    9.     abstract static class Sync extends AbstractQueuedSynchronizer {
    10.         private static final long serialVersionUID = -5179523762034025860L;

     Redis分布式锁实现：

    (66条消息) redis通过lua脚本实现分布式锁_Maxiao1204的博客-CSDN博客_lua实现redis分布式锁

    (66条消息) aqs的学习_Fairy要carry的博客-CSDN博客

     1.首先是setnx命令实现分布式锁

    加锁：其实就是cas操作，只有当key不存在的情况，才能将key的值设置为value，如果key已经存在了，那么setnx命令不做任何操作（Set if Not Exists）

    setnx key value

    那么setnx怎么释放锁呢？

     直接del key就ok了

    del key

     2.问题之设置过期时间防止别人拿不到锁）

    1.比如我们加锁后，如果忘记del锁的话，那么其他线程就一直无法获取到这个锁，造成一线程资源空转——>解决：上过期时间即可，所以说我们常说的redis分布式锁最基本的就是setnx+expire

    set lock 746879613 nx ex 20

    这里的nx和xx的区别

    (35条消息) Redis - NX与XX_平_繁的博客-CSDN博客_redis xx

    nx：如果不存在就会设置该值

    xx：如果存在就会覆盖该值 

    3.问题之设置uuid防止误删现象发生

    首先看redis分布式锁的流程

    1.加锁设置过期时间（一条命令保证原子性）

    2.进行业务处理

    3.然后del锁

    场景：当A服务拿到了锁然后执行业务，业务时间很长>默认释放锁的时间，那么此时就会B拿到锁，然后再A业务执行完业务执行删除del时，会发现删的就是B服务的锁了

    ——>解决：加锁的时候除了设置过期时间并且设置UUID，然后删除的时候进行验证是不是该服务的，我们利用setIfAbsent(lockName，uuid，3，TimeUnit.SECONDS)设置lock的名称以及值也就是uuid作为标识——>(后面的可重入实现就得用lua脚本了，毕竟多了一个重复次数值)

    1.   /**
    2.      * 5.redis分布式锁循环实现（cas）
    3.      */
    4.     public void deduct5() {
    5.         String uuid = UUID.randomUUID().toString();//每个请求自己的锁标识
    6.         /**
    7.          * 1.加锁setnx，并且设置过期时间-尽量保证原子性(不存在这个key就进行设置)
    8.          */
    9.         Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 3, TimeUnit.SECONDS);
    10.  
    11.         /**
    12.          * 2.判断是否获取锁成功
    13.          */
    14.         while (!lock) {//没获取到锁进行sleep
    15.             try {
    16.                 Thread.sleep(50);
    17. //                //2.1不成功进行cas操作——>此时递归操作可能会造成多次扣减库存的操作——>重复几次就扣减几次
    18. //                this.deduct5();
    19.             } catch (InterruptedException e) {
    20.                 e.printStackTrace();
    21.             }
    22.         }
    23.  
    24.         /**
    25.          *  3.成功的执行操作
    26.          */
    27.         try {
    28.             //1.查询库存信息
    29.             Integer stock = (Integer) redisTemplate.opsForValue().get("stock");
    30.             //2.判断库存是否充足
    31.             if (stock != null && stock > 0) {
    32.                 redisTemplate.opsForValue().set("stock", stock - 1);
    33.             }
    34.         } finally {
    35.            
    36.             /**
    37.              * 3.解锁需要判断是否是自己的锁
    38.              * 注意：我们需要保证原子性，因为可能出现请求1执行然后3s后释放lock
    39.              * ——>请求2进来的时候获得了自己的uuid并且拿到了锁
    40.              * ——>请求1还没走完刚好到了finally这里，判断锁的值和uuid相等把请求2的锁删了——>需要保证原子性
    41.              */
    42.             if(StringUtils.equals(this.redisTemplate.opsForValue().get("lock").toString(),uuid)){
    43.                 /**
    44.                  * 4.进行解锁，将锁释放（可能出现误删现象）
    45.                  * 误删：比如我们第一个请求3s后自动释放锁资源，然后被请求2拿到，但是此时请求1的执行流程还没走完
    46.                  * ——>当请求1在finally的时候会删除lock锁资源，删除请求2的造成误删现象
    47.                  */
    48.                 this.redisTemplate.delete("lock");
    49.             }
    50.         }

    4.问题之最后判断+删除这里没有保证原子性： 

    当服务A业务执行完判断——>lock的值是否和当前事务的uuid值一样——>然后进行del，当判断完还没del时，加入锁过期了，事务B拿到锁资源，然后事务A之前就判断完了一删，B的锁就会被误删（没有保证判断和删除的原子性）

    解决：用lua脚本

    1.  /**
    2.      * 5.redis分布式锁循环实现（cas）
    3.      */
    4.     public void deduct5() {
    5.         String uuid = UUID.randomUUID().toString();//每个请求自己的锁标识
    6.         /**
    7.          * 1.加锁setnx，并且设置过期时间-尽量保证原子性(不存在这个key就进行设置)
    8.          */
    9.         Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 3, TimeUnit.SECONDS);
    10.  
    11.         /**
    12.          * 2.判断是否获取锁成功
    13.          */
    14.         while (!lock) {//没获取到锁进行sleep
    15.             try {
    16.                 Thread.sleep(50);
    17. //                //2.1不成功进行cas操作——>此时递归操作可能会造成多次扣减库存的操作——>重复几次就扣减几次
    18. //                this.deduct5();
    19.             } catch (InterruptedException e) {
    20.                 e.printStackTrace();
    21.             }
    22.         }
    23.  
    24.         /**
    25.          *  3.成功的执行操作
    26.          */
    27.         try {
    28.             //1.查询库存信息
    29.             Integer stock = (Integer) redisTemplate.opsForValue().get("stock");
    30.             //2.判断库存是否充足
    31.             if (stock != null && stock > 0) {
    32.                 redisTemplate.opsForValue().set("stock", stock - 1);
    33.             }
    34.         } finally {
    35.              String script="if redis.call('get',KEYS[1]) == ARGV[1] "+
    36.                      "then "+
    37.                      "  return redis.call('del','KEYS[1]')"+
    38.                      "else"+
    39.                      "  return 0 "+
    40.                      "end";
    41.              this.redisTemplate.execute(new DefaultRedisScript<>(script,Boolean.class), Arrays.asList("lock"),uuid);
    42.  
    43.             }
    44.         }

    5.问题之lock功能可重入的实现+重写加锁流程

    原来的加锁方式是：setIfAbsent()——>这样加锁，lock只有一个值，就是uuid，作为我们线程的标识，那么我们如果可重入的话就需要再来个值放在uuid下面

    解决：我们可以利用hset——>设置锁名称为testlock，拥有标识为wyh，重入次数为1

    hset testlock wyh 1

    也可以利用incr，更推荐方便lua脚本编写，既可以作为增加重入次数，又可以作为创建新的锁

    加锁核心代码

    1.我们自定义一个分布式锁，然后实现Lock接口（类似ReentranLock，实现lock接口，并且aqs帮助了一个思路，但是具体的逻辑还是ReentrantLock自己实现）

    2.这里主要看我们的lua逻辑——>首先判断是否有这个锁，没有就直接创建一个锁并且设置标识以及当前重入次数1——>如果当前有锁并且是自己本身，也是一样利用incr增加重入次数——>否则返回0（注：参数lockName，uuid，过期时间u）

    3.然后redisTemplate执行我们这个lua脚本，如果执行失败就进行cas——>sleep，获取锁成功返回true（锁自动续期问题后面说——>当前线程执行业务的时间太长>锁释放时间，导致锁提前释放——>导致B事务拿到锁后，A事务执行业务完后删不掉锁（需要比较uuid标识），确实也不需要删，只是这样隔离性较差）

    1.  /**
    2.      * 2.核心加锁方法
    3.      *
    4.      * @param time
    5.      * @param unit
    6.      * @return
    7.      * @throws InterruptedException
    8.      */
    9.     @Override
    10.     public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    11.         if (time != -1) {
    12.             //2.1指定了时间设置为你指定的
    13.             this.expire = unit.toSeconds(time);
    14.         }
    15.  
    16.         /**
    17.          * 2.2判断锁是否存在，判断对应锁的标识，也就是uuid下的拥有者是否存在
    18.          * 如果不存在（也就是为0）的话就加锁值为1（代表第一次加锁），并且设置过期时间——>返回1，否则返回0
    19.          */
    20.         String script = "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 " +
    21.                 "then " +
    22.                 "   redis.call('hincrby', KEYS[1], ARGV[1], 1) " +
    23.                 "   redis.call('expire', KEYS[1], ARGV[2]) " +
    24.                 "   return 1 " +
    25.                 "else " +
    26.                 "   return 0 " +
    27.                 "end";
    28.         while (!this.redisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuid, String.valueOf(expire))) {
    29.             //2.3执行失败，循环尝试获取锁
    30.             Thread.sleep(50);
    31.         }
    32.  
    33.         /**
    34.          * 2.4获取锁成功
    35.          * 先获取自动续期
    36.          */
    37.         this.renewExpire();
    38.         return true;
    39.     }

     6.lua脚本重写解锁功能

    好处：前面都有说保证了我们加锁解锁的原子性，并且包含了各种可能的逻辑 

    1.判断是否有锁（并且符合标识，用hexists），比如wyh这个锁，标识为746879613的是否存在——>2.不存在返回nil——>3.如果存在进行解锁，hincrby将锁注入次数-1——>4.否则解锁失败返回0——>5.进行执行，如果返回为nil，说明解不了当前锁

    然后我们锁标识uuid是通过线程+服务结合而来的 

    HEXISTS wyh 746879613
    1.   /**
    2.      * 3.解锁方法
    3.      */
    4.     @Override
    5.     public void unlock() {
    6.  
    7.         /**
    8.          * 3.1判断线程是否拥有该锁（用uuid来判断）——>HEXISTS lock 746879613
    9.          * ——>如果不存在说明解不了return nil——>如果解的了就-1，若-为0就删除
    10.          */
    11.         String script = "if redis.call('hexists', KEYS[1], ARGV[1]) == 0 " +
    12.                 "then " +
    13.                 "   return nil " +
    14.                 "elseif redis.call('hincrby', KEYS[1], ARGV[1], -1) == 0 " +
    15.                 "   then return redis.call('del', KEYS[1]) " +
    16.                 "else " +
    17.                 "   return 0 " +
    18.                 "end";
    19.         Long flag = this.redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName), uuid);
    20.         //判断结果异常
    21.         if (flag == null) {
    22.             throw new IllegalMonitorStateException("锁不属于你");
    23.         }
    24.     }

    7.自定义分布式锁的构造+uuid识别

     思路：1.我们的锁名称，redisTemplate这些由我们自定义的一个工厂类传入，并且设置过期时间——>2.uuid：由我们的工厂类（传入第一个标识（服务的）），与当前线程的uuid结合起来

    工厂类：

    1. package com.wyh.fbs_demo.com.wyh.lock;
    2.  
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.data.redis.core.StringRedisTemplate;
    5. import org.springframework.stereotype.Component;
    6.  
    7. import java.util.UUID;
    8.  
    9. /**
    10.  * 工厂类：提供redis的mysql的分布式锁
    11.  */
    12. @Component
    13. public class DistributedLockClient {
    14.  
    15.     @Autowired
    16.     private StringRedisTemplate redisTemplate;
    17.  
    18.     //不同服务的uuid
    19.     private String uuid;
    20.  
    21.     public DistributedLockClient() {
    22.         this.uuid= UUID.randomUUID().toString();
    23.     }
    24.  
    25.     /**
    26.      * 1.返回redis分布式锁，并且指定锁名称
    27.      * @param name：锁名称
    28.      * @return
    29.      */
    30.     public DistributeRedisLock getRedisLock(String name){
    31.         return  new DistributeRedisLock(redisTemplate,name,uuid);
    32.     }
    33.  
    34. }

    锁构造： 

    1. /**
    2.  * Redis分布式锁没有被容器管理
    3.  * 所以切记不能Autowired
    4.  */
    5. public class DistributeRedisLock implements Lock {
    6.  
    7.     private StringRedisTemplate redisTemplate;
    8.  
    9.     public String lockName;//锁的名称
    10.  
    11.     private String uuid;//拥有锁的标识
    12.  
    13.     private long expire = 30;//默认过期时间
    14.  
    15.     /**
    16.      * 1.构造redis分布式锁
    17.      *
    18.      * @param redisTemplate
    19.      * @param lockName：锁名称
    20.      * @param uuid:每个服务的uuid标识
    21.      */
    22.     public DistributeRedisLock(StringRedisTemplate redisTemplate, String lockName, String uuid) {
    23.         this.redisTemplate = redisTemplate;
    24.         this.lockName = lockName;
    25.         this.uuid = uuid + ":" + Thread.currentThread().getId();//每个服务的id标识
    26.     }

    所有代码 

    1. package com.wyh.fbs_demo.com.wyh.lock;
    2.  
    3. import org.springframework.data.redis.core.StringRedisTemplate;
    4. import org.springframework.data.redis.core.script.DefaultRedisScript;
    5.  
    6. import java.util.Arrays;
    7. import java.util.Timer;
    8. import java.util.TimerTask;
    9. import java.util.UUID;
    10. import java.util.concurrent.TimeUnit;
    11. import java.util.concurrent.locks.Condition;
    12. import java.util.concurrent.locks.Lock;
    13.  
    14. /**
    15.  * Redis分布式锁没有被容器管理
    16.  * 所以切记不能Autowired
    17.  */
    18. public class DistributeRedisLock implements Lock {
    19.  
    20.     private StringRedisTemplate redisTemplate;
    21.  
    22.     public String lockName;//锁的名称
    23.  
    24.     private String uuid;//拥有锁的标识
    25.  
    26.     private long expire = 30;//默认过期时间
    27.  
    28.     /**
    29.      * 1.构造redis分布式锁
    30.      *
    31.      * @param redisTemplate
    32.      * @param lockName：锁名称
    33.      * @param uuid:每个服务的uuid标识
    34.      */
    35.     public DistributeRedisLock(StringRedisTemplate redisTemplate, String lockName, String uuid) {
    36.         this.redisTemplate = redisTemplate;
    37.         this.lockName = lockName;
    38.         this.uuid = uuid + ":" + Thread.currentThread().getId();//每个服务的id标识
    39.     }
    40.  
    41.     @Override
    42.     public void lock() {
    43.         //1.尝试获取锁
    44.         this.tryLock();
    45.     }
    46.  
    47.  
    48.     @Override
    49.     public void lockInterruptibly() throws InterruptedException {
    50.  
    51.     }
    52.  
    53.     @Override
    54.     public boolean tryLock() {
    55.         try {
    56.             //1.加锁核心，设置默认的过期时间
    57.             return this.tryLock(-1L, TimeUnit.SECONDS);
    58.         } catch (InterruptedException e) {
    59.             e.printStackTrace();
    60.         }
    61.         return false;
    62.     }
    63.  
    64.     /**
    65.      * 2.核心加锁方法
    66.      *
    67.      * @param time
    68.      * @param unit
    69.      * @return
    70.      * @throws InterruptedException
    71.      */
    72.     @Override
    73.     public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    74.         if (time != -1) {
    75.             //2.1指定了时间设置为你指定的
    76.             this.expire = unit.toSeconds(time);
    77.         }
    78.  
    79.         /**
    80.          * 2.2判断锁是否存在，判断对应锁的标识，也就是uuid下的拥有者是否存在
    81.          * 如果不存在（也就是为0）的话就加锁值为1（代表第一次加锁），并且设置过期时间——>返回1，否则返回0
    82.          */
    83.         String script = "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 " +
    84.                 "then " +
    85.                 "   redis.call('hincrby', KEYS[1], ARGV[1], 1) " +
    86.                 "   redis.call('expire', KEYS[1], ARGV[2]) " +
    87.                 "   return 1 " +
    88.                 "else " +
    89.                 "   return 0 " +
    90.                 "end";
    91.         while (!this.redisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuid, String.valueOf(expire))) {
    92.             //2.3执行失败，循环尝试获取锁
    93.             Thread.sleep(50);
    94.         }
    95.  
    96.         /**
    97.          * 2.4获取锁成功
    98.          * 先获取自动续期
    99.          */
    100.         this.renewExpire();
    101.         return true;
    102.     }
    103.  
    104.     /**
    105.      * 3.解锁方法
    106.      */
    107.     @Override
    108.     public void unlock() {
    109.  
    110.         /**
    111.          * 3.1判断线程是否拥有该锁（用uuid来判断）——>HEXISTS lock 746879613
    112.          * ——>如果不存在说明解不了return nil——>如果解的了就-1，若-为0就删除
    113.          */
    114.         String script = "if redis.call('hexists', KEYS[1], ARGV[1]) == 0 " +
    115.                 "then " +
    116.                 "   return nil " +
    117.                 "elseif redis.call('hincrby', KEYS[1], ARGV[1], -1) == 0 " +
    118.                 "   then return redis.call('del', KEYS[1]) " +
    119.                 "else " +
    120.                 "   return 0 " +
    121.                 "end";
    122.         Long flag = this.redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName), uuid);
    123.         //判断结果异常
    124.         if (flag == null) {
    125.             throw new IllegalMonitorStateException("锁不属于你");
    126.         }
    127.     }
    128.  
    129.     @Override
    130.     public Condition newCondition() {
    131.         return null;
    132.     }
    133.  
    134.     /**
    135.      * 4.获取当前线程的id，与服务id做拼接保证唯一性
    136.      *
    137.      * @return
    138.      */
    139. //    String getId() {
    140. //        return uuid + ":" + Thread.currentThread().getId();
    141. //    }
    142.  
    143.     /**
    144.      * 5.定时器功能——>重置时间自动续期
    145.      */
    146.     private void renewExpire() {
    147.         String script = "if redis.call('hexists',KEYS[1],ARGV[1]) == 1 " +
    148.                 "then " +
    149.                 "   return redis.call('expire',KEYS[1],ARGV[2]) " +
    150.                 "else " +
    151.                 "   return 0 " +
    152.                 "end";
    153.         new Timer().schedule(new TimerTask() {
    154.             @Override
    155.             public void run() {
    156.                 //这里注意子线程需要的uuid肯定得和父id一样，不然获得不了锁
    157.                 Boolean flag = redisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuid, String.valueOf(expire));
    158.                 if (flag) {
    159.                    renewExpire();
    160.                 }
    161.             }
    162.         }, this.expire * 1000 / 3, this.expire * 1000 / 3);
    163.     }
    164.  
    165. }


    测试：

    1. @Service
    2. //@Scope(value = "prototype",proxyMode = ScopedProxyMode.TARGET_CLASS)
    3. public class StockService {
    4.  
    5.     @Resource(name = "redisTemplate")
    6.     private RedisTemplate redisTemplate;
    7.     @Autowired
    8.     private StockMapper stockMapper;
    9.     //注入工厂类
    10.     @Autowired
    11.     private DistributedLockClient client;
    12.  
    13.  
    14. //    @Autowired
    15. //    private ReentrantLock lock = new ReentrantLock();
    16.  
    17.     /**
    18.      * 6.redis分布式锁实现——可重入加锁减锁
    19.      */
    20.     public void deduct6(){
    21.         /**
    22.          * 1.获取redis分布式锁
    23.          */
    24.         DistributeRedisLock redisLock = this.client.getRedisLock("lock");
    25.         redisLock.lock();
    26.  
    27.         try {
    28.             /**
    29.              * 2.对库存信息进行操作
    30.              */
    31.             String stock = redisTemplate.opsForValue().get("stock").toString();
    32.  
    33.             //2.1判断库存是否充足
    34.             if(stock!=null&&stock.length()!=0){
    35.                 Integer st = Integer.valueOf(stock);
    36.                 //2.2将库存减-1
    37.                 if(st>0) redisTemplate.opsForValue().set("stock",String.valueOf(--st));
    38.             }
    39.             //2.3可重入测试
    40.             this.test();
    41.         } finally {
    42.             /**
    43.              * 3.解锁
    44.              */
    45.             redisLock.unlock();
    46.         }
    47.  
    48.     }
    49.  
    50.     /**
    51.      * 7.测试可重入
    52.      */
    53.     public void test(){
    54.         DistributeRedisLock lock = this.client.getRedisLock("lock");
    55.         lock.lock();
    56.         System.out.println("测试可重入锁....");
    57.         lock.unlock();
    58.     }
    59. }

  • 相关阅读:
    【无标题】
    （附源码）spring boot大学英语智慧教学平台 毕业设计 201722
    340页11万字智慧政务大数据资源平台大数据底座数据治理建设方案
    技能 | 在项目中集成Sentry
    下载nvm管理node版本
    Java内存模型之happens-before
    当EAI遇见RPA：破解接口难题，助力数据打通
    学习gmock
    单元测试探析：什么是Stubs、Mocks、Spies、Dummies？带你了解4个核心工具
    微信小程序简单输入框界面（实现选择标签功能）
  • 原文地址：https://blog.csdn.net/weixin_57128596/article/details/126881970