JedisLock基于Redis实现分布式锁

小鱼儿 2022-02-02 11:59 252阅读 0赞

一、 背景  
实际的项目开发过程中我们常常遇到高并发访问，容易导致数据不同步，例如：库存的增加， 故此我们可以通过Redis提供的特性实现分布式锁，以达到数据的同步性。本文通过Redis的客户端JedisLock来实现。

注：该文是本博主记录学习之用，没有太多详细的讲解，敬请谅解！

二、 Redis实现分布式锁的原理  
1、选用Redis实现分布式锁原因：

（1）Redis有很高的性能；  
（2）Redis命令对此支持较好，实现起来比较方便

2、使用命令介绍：

（1）SETNX

SETNX key val：当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。

（2）expire

expire key timeout：为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。

（3）delete

delete key：删除key

在使用Redis实现分布式锁的时候，主要就会使用到这三个命令。

3、实现思想：

（1）获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。

（2）获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。

（3）释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。

流程图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dhb3dlbmh1aTIwMDg_size_16_color_FFFFFF_t_70][]

三、添加Maven依赖  
<dependency>  
    <groupId>com.github.jedis-lock</groupId>  
    <artifactId>jedis-lock</artifactId>  
    <version>1.0.0</version>  
</dependency>  
  
四、代码示例

package com.vcyber.user.util;
    
    import com.github.jedis.lock.JedisLock;
    import redis.clients.jedis.Jedis;
    
    public class JedisLockTest {
    
        public static void main(String[] args) throws InterruptedException {
            for (int i=0;i<10;i++){
                int num = i;
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Jedis jedis=new Jedis("127.0.0.1",6379);
                        lock(jedis,"key", num);
                    }
                }).start();
            }
    
        }
    
        public static void lock(Jedis jedis, String key,int i){
            JedisLock jedisLock=new JedisLock(jedis,key,2000,2000);
            try {
                //获得锁
                jedisLock.acquire();
                System.out.println(i+"获得锁");
                if(i==2){
                    //该代码块是为了验证效果
                    System.out.println(i+"睡眠2秒....");
                    Thread.sleep(2000);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                System.out.println(i+"释放锁");
                if(jedisLock!=null){
                    //释放锁
                    jedisLock.release();
                }
                if(jedis!=null){
                    jedis.close();
                }
            }
        }
    
    }
    
    
    效果图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dhb3dlbmh1aTIwMDg_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dhb3dlbmh1aTIwMDg_size_16_color_FFFFFF_t_70 2][]

对于JedisLock如何基于Redis来实现锁的效果，本文就不一一描述，各位可自行看源码理解！

以下贴上源码以供学习：

//  
// Source code recreated from a .class file by IntelliJ IDEA  
// (powered by Fernflower decompiler)  
//

package com.github.jedis.lock;

import redis.clients.jedis.Jedis;

public class JedisLock \{  
    Jedis jedis;  
    String lockKey;  
    int expireMsecs;  
    int timeoutMsecs;  
    boolean locked;

public JedisLock(Jedis jedis, String lockKey) \{  
        this.expireMsecs = 60000;  
        this.timeoutMsecs = 10000;  
        this.locked = false;  
        this.jedis = jedis;  
        this.lockKey = lockKey;  
    \}

public JedisLock(Jedis jedis, String lockKey, int timeoutMsecs) \{  
        this(jedis, lockKey);  
        this.timeoutMsecs = timeoutMsecs;  
    \}

public JedisLock(Jedis jedis, String lockKey, int timeoutMsecs, int expireMsecs) \{  
        this(jedis, lockKey, timeoutMsecs);  
        this.expireMsecs = expireMsecs;  
    \}

public JedisLock(String lockKey) \{  
        this((Jedis)null, lockKey);  
    \}

public JedisLock(String lockKey, int timeoutMsecs) \{  
        this((Jedis)null, lockKey, timeoutMsecs);  
    \}

public JedisLock(String lockKey, int timeoutMsecs, int expireMsecs) \{  
        this((Jedis)null, lockKey, timeoutMsecs, expireMsecs);  
    \}

public String getLockKey() \{  
        return this.lockKey;  
    \}

public synchronized boolean acquire() throws InterruptedException \{  
        return this.acquire(this.jedis);  
    \}  
      
    /\*\*  
     \* 获得 lock.  
     \* 实现思路: 主要是使用了redis 的setnx命令,缓存了锁.  
     \* reids缓存的key是锁的key,所有的共享, value是锁的到期时间(注意:这里把过期时间放在value了,没有时间上设置其超时时间)  
     \* 执行过程:  
     \* 1.通过setnx尝试设置某个key的值,成功(当前没有这个锁)则返回,成功获得锁  
     \* 2.锁已经存在则获取锁的到期时间,和当前时间比较,超时的话,则设置新的值  
     \*  
     \*/  
       
    public synchronized boolean acquire(Jedis jedis) throws InterruptedException \{  
        int timeout = this.timeoutMsecs;

while(timeout >= 0) \{  
            long expires = System.currentTimeMillis() + (long)this.expireMsecs + 1L;  
            String expiresStr = String.valueOf(expires);  //锁到期时间  
            if (jedis.setnx(this.lockKey, expiresStr) == 1L) \{  
                this.locked = true;  
                return true;  
            \}  
          //判断是否为空，不为空的情况下，如果被其他线程设置了值，则第二个条件判断是过不去的  
          //获取上一个锁到期时间，并设置现在的锁到期时间，  
          //只有一个线程才能获取上一个线上的设置时间，因为jedis.getSet是同步的  
            String currentValueStr = jedis.get(this.lockKey);  
            if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) \{  
                String oldValueStr = jedis.getSet(this.lockKey, expiresStr);  
                if (oldValueStr != null && oldValueStr.equals(currentValueStr)) \{  
                    this.locked = true;  
                    return true;  
                \}  
            \}

timeout -= 100;  
            Thread.sleep(100L);  
        \}

return false;  
    \}

public synchronized void release() \{  
        this.release(this.jedis);  
    \}

public synchronized void release(Jedis jedis) \{  
        if (this.locked) \{  
            jedis.del(new String\[\]\{this.lockKey\});  
            this.locked = false;  
        \}

\}  
\}

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dhb3dlbmh1aTIwMDg_size_16_color_FFFFFF_t_70]: /images/20220202/efcfb8a3b5b74b93826433a09ab90b74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dhb3dlbmh1aTIwMDg_size_16_color_FFFFFF_t_70 1]: /images/20220202/7dc47d85cf444bf6915afe3d9800df1f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2dhb3dlbmh1aTIwMDg_size_16_color_FFFFFF_t_70 2]: /images/20220202/12dfc4fa3cb440ec93690234dab5372c.png