手写Redis的分布式锁

设计一个锁
实现JUC中Java.util.concurrent.locks.Lock接口,按照Lock接口的规范设置自己的锁
加锁规范: 1.避免栈溢出->自旋锁 2.设置过期时间 3. 加锁的原子性 4.自动续期
解锁规范:1.判定删除的是同一把锁 2.解锁时的原子性

锁的种类
单机版同一个JVM虚拟机内,synchronized或者Lock接口。
分布式多个不同JVM虚拟机,单机的线程锁机制不再起作用,资源类在不同的服务器之间共享了。
在这里插入图片描述
分布式锁所需要的条件和刚需
独占性:任何时刻有且仅有一个线程持有
高可用:若redis集群环境下,不能因为某一个节点挂了而出现获取锁和释放锁失败的情况。高并发请求下,依旧性能OK好使。
防死锁:杜绝死锁,必须有超时控制机制或者撤销操作。
不乱抢:不可以抢占释放别的资源的锁,只能自己加锁,自己释放。
重入性:同一个节点的同一个线程如果获得锁之后,它也可以再次获取这个锁。

setnx key value
set key value [EX seconds][PX milliseconds][NX|XX]
#ex:表示key在多少秒后过期
#PX:表示key在多少毫秒后过期
#NX:当key不存在时才创建key
#XX:当key存在时,覆盖key

手写分布式锁

public class InventoryService
{
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Value("${server.port}")
    private String port;

    private Lock lock = new ReentrantLock();

    public String sale()
    {
        String retMessage = "";
        lock.lock();
        try
        {
            //1 查询库存信息
            String result = stringRedisTemplate.opsForValue().get("inventory001");
            //2 判断库存是否足够
            Integer inventoryNumber = result == null ? 0 : Integer.parseInt(result);
            //3 扣减库存
            if(inventoryNumber > 0) {
                stringRedisTemplate.opsForValue().set("inventory001",String.valueOf(--inventoryNumber));
                retMessage = "成功卖出一个商品,库存剩余: "+inventoryNumber;
                System.out.println(retMessage);
            }else{
                retMessage = "商品卖完了,o(╥﹏╥)o";
            }
        }finally {
            lock.unlock();
        }
        return retMessage+"\t"+"服务端口号:"+port;
    }
}

在单机环境下,可以使用synchronized或Lock来实现。
但是在分布式系统中,因为竞争的线程可能不在同一个节点上(同一个jvm中),所以需要一个让所有进程都能访问到的锁来实现(比如redis或者zookeeper来构建), 不同进程jvm层面的锁就不管用了,那么可以利用第三方的一个组件,来获取锁,未获取到锁,则阻塞当前想要运行的线程。

分布式锁可以解决的问题:
1.跨进程、跨服务
2.解决超卖
3.防止缓存击穿(数据不在缓存中但是在数据库中)‘

Redis的分布式锁
在这里插入图片描述
利用redis实现分布式锁
3.1

@Service
@Slf4j
public class InventoryService
{
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Value("${server.port}")
    private String port;

    private Lock lock = new ReentrantLock();

    public String sale()
    {
        String retMessage = "";
        String key = "zzyyRedisLock";
        String uuidValue = IdUtil.simpleUUID()+":"+Thread.currentThread().getId();

        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue);
        if(!flag){
            //暂停20毫秒后递归调用
            try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
            sale();
        }else{
            try{
                //1 查询库存信息
                String result = stringRedisTemplate.opsForValue().get("inventory001");
                //2 判断库存是否足够
                Integer inventoryNumber = result == null ? 0 : Integer.parseInt(result);
                //3 扣减库存
                if(inventoryNumber > 0) {
                    stringRedisTemplate.opsForValue().set("inventory001",String.valueOf(--inventoryNumber));
                    retMessage = "成功卖出一个商品,库存剩余: "+inventoryNumber;
                    System.out.println(retMessage);
                }else{
                    retMessage = "商品卖完了,o(╥﹏╥)o";
                }
            }finally {
                stringRedisTemplate.delete(key);
            }
        }
        return retMessage+"\t"+"服务端口号:"+port;
    }
}

设置 UUID:线程名,若未获取到锁,则递归调用,直到获取到锁。
3.2
问题: 采用递归的方式获取锁容易造成栈溢出(类似JUC中的虚假唤醒),因此用while替代if =>即采用自旋锁代替递归重试。

  while(!stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue)){
            //暂停20毫秒,类似CAS自旋
            try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
        }

3.3
问题:解决了容易栈溢出的问题,然而部署了微服务的JAVA程序机器挂了之后,代码走不到finnally,因此锁无法删除,key将一直存在,影响程序的运行,因此需要引入过期时间

while(!stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue))
{
    //暂停20毫秒,进行递归重试.....
    try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
}

stringRedisTemplate.expire(key,30L,TimeUnit.SECONDS);

3.4
上述设置key+过期时间分开了操作不具有原子性,因此需要将设置key以及过期时间合并为一行

        while(!stringRedisTemplate.opsForValue().setIfAbsent(key, uuidValue,30L,TimeUnit.SECONDS))
        {
            //暂停毫秒
            try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
        }

3.5
实际业务处理时间超过了默认设置的key的过期时间,因此只能删除自身的key不能删除别的线程设置的key

在这里插入代码片

在这里插入图片描述

finally {
            // v5.0判断加锁与解锁是不是同一个客户端,同一个才行,自己只能删除自己的锁,不误删他人的
            if(stringRedisTemplate.opsForValue().get(key).equalsIgnoreCase(uuidValue)){
                stringRedisTemplate.delete(key);
            }
        }

3.6
删除锁部分没有实现原子操作,故使用lua脚本,实现原子操作。
Redis调用Lua脚本通过eval命令保证代码执行的原子性,直接用return返回脚本执行后的结果值。
eval luascript numkeys [key [key …]] [arg [arg …]

finally {
            //V6.0 将判断+删除自己的合并为lua脚本保证原子性
            String luaScript =
                    "if (redis.call('get',KEYS[1]) == ARGV[1]) then " +
                        "return redis.call('del',KEYS[1]) " +
                    "else " +
                        "return 0 " +
                    "end";
            stringRedisTemplate.execute(new DefaultRedisScript<>(luaScript, Boolean.class), Arrays.asList(key), uuidValue);
        }

3.7可重入锁

可重入锁又名递归锁
是指在同一个线程在外层方法获取锁的时候,再进入该线程的内层方法会自动获取锁(前提,锁对象得是同一个对象),不会因为之前已经获取过还没释放而阻塞。
如果是1个有 synchronized 修饰的递归调用方法,程序第2次进入被自己阻塞了岂不是天大的笑话,出现了作茧自缚。
所以Java中ReentrantLock和synchronized都是可重入锁,可重入锁的一个优点是可一定程度避免死锁
可重入锁的种类:
隐式锁:synchronized关键字使用的锁,默认是可重入锁
显式锁:Lock,例如ReentrantLock
Synchronized重入的实现机理
每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针。
当执行monitorenter时,如果目标锁对象的计数器为零,那么说明它没有被其他线程所持有,Java虚拟机会将该锁对象的持有线程设置为当前线程,并且将其计数器加1。
在目标锁对象的计数器不为零的情况下,如果锁对象的持有线程是当前线程,那么 Java 虚拟机可以将其计数器加1,否则需要等待,直至持有线程释放该锁。
当执行monitorexit时,Java虚拟机则需将锁对象的计数器减1。计数器为零代表锁已被释放。
因此需要使用K,K,V 类型的数据结构:Map<String,Map<Object,Object>>
hset key field value
hset redis锁名字(zzyyRedisLock) 某个请求线程的UUID+ThreadID 加锁的次数
因此hset可以解决可重入的问题

public class RedisDistributedLock implements Lock
{
    private StringRedisTemplate stringRedisTemplate;

    private String lockName;//KEYS[1]
    private String uuidValue;//ARGV[1]
    private long   expireTime;//ARGV[2]
    public RedisDistributedLock(StringRedisTemplate stringRedisTemplate, String lockName)
    {
        this.stringRedisTemplate = stringRedisTemplate;
        this.lockName = lockName;
        this.uuidValue = IdUtil.simpleUUID()+":"+Thread.currentThread().getId();//UUID:ThreadID
        this.expireTime = 30L;
    }
    @Override
    public void lock()
    {
        tryLock();
    }
    @Override
    public boolean tryLock()
    {
        try {tryLock(-1L,TimeUnit.SECONDS);} catch (InterruptedException e) {e.printStackTrace();}
        return false;
    }

    /**
     * 干活的,实现加锁功能,实现这一个干活的就OK,全盘通用
     * @param time
     * @param unit
     * @return
     * @throws InterruptedException
     */
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException{
        if(time != -1L){
            this.expireTime = unit.toSeconds(time);
        }
        String script =
                "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then " +
                        "redis.call('hincrby',KEYS[1],ARGV[1],1) " +
                        "redis.call('expire',KEYS[1],ARGV[2]) " +
                        "return 1 " +
                "else " +
                        "return 0 " +
                "end";

        System.out.println("script: "+script);
        System.out.println("lockName: "+lockName);
        System.out.println("uuidValue: "+uuidValue);
        System.out.println("expireTime: "+expireTime);

        while (!stringRedisTemplate.execute(new DefaultRedisScript<>(script,Boolean.class), Arrays.asList(lockName),uuidValue,String.valueOf(expireTime))) {
            TimeUnit.MILLISECONDS.sleep(50);
        }
        return true;
    }

    /**
     *干活的,实现解锁功能
     */
    @Override
    public void unlock()
    {
        String script =
                "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 0 then " +
                "   return nil " +
                "elseif redis.call('HINCRBY',KEYS[1],ARGV[1],-1) == 0 then " +
                "   return redis.call('del',KEYS[1]) " +
                "else " +
                "   return 0 " +
                "end";
        // nil = false 1 = true 0 = false
        System.out.println("lockName: "+lockName);
        System.out.println("uuidValue: "+uuidValue);
        System.out.println("expireTime: "+expireTime);
        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName),uuidValue,String.valueOf(expireTime));
        if(flag == null)
        {
            throw new RuntimeException("This lock doesn't EXIST");
        }

    }

    //===下面的redis分布式锁暂时用不到=======================================
    //===下面的redis分布式锁暂时用不到=======================================
    //===下面的redis分布式锁暂时用不到=======================================
    @Override
    public void lockInterruptibly() throws InterruptedException
    {

    }

    @Override
    public Condition newCondition()
    {
        return null;
    }
}

实际上tryLock实现加锁操作,unlock实现解锁操作。

3.8 自动续期
确保redisLock的过期时间大于业务执行时间


//==============自动续期
if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 1 then
  return redis.call('expire',KEYS[1],ARGV[2])
else
  return 0
end
   private void renewExpire()
    {
        String script =
                "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 1 then " +
                        "return redis.call('expire',KEYS[1],ARGV[2]) " +
                        "else " +
                        "return 0 " +
                        "end";

        new Timer().schedule(new TimerTask()
        {
            @Override
            public void run()
            {
                if (stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName),uuidValue,String.valueOf(expireTime))) {
                    renewExpire();
                }
            }
        },(this.expireTime * 1000)/3);
    }

每隔十秒更新一下过期时间

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
手写Redis分布式锁的一个常见方法是使用Redis的SETNX命令和EXPIRE命令。SETNX用于设置一个键值对,只有在键不存在的情况下才能设置成功,用于表示获取锁的操作。EXPIRE用于设置键的过期时间,确保在获取锁的客户端崩溃或网络故障的情况下,锁最终会被释放。 下面是一个用C语言手写Redis分布式锁的简单示例代码: ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/types.h> #include <sys/time.h> #include <sys/wait.h> #include <signal.h> #include <errno.h> #include <hiredis/hiredis.h> #define REDIS_HOST "localhost" #define REDIS_PORT 6379 #define LOCK_KEY "my_lock" #define LOCK_EXPIRE_TIME 10 int main() { pid_t child_pid; int status; // 创建子进程 child_pid = fork(); if (child_pid == 0) { // 子进程获取锁 redisContext *redis_conn = redisConnect(REDIS_HOST, REDIS_PORT); if (redis_conn == NULL || redis_conn->err) { printf("连接Redis失败\n"); exit(1); } // 设置锁 redisReply *reply = redisCommand(redis_conn, "SETNX %s 1", LOCK_KEY); if (reply == NULL || reply->type == REDIS_REPLY_ERROR || reply->integer != 1) { printf("获取锁失败\n"); exit(1); } // 设置锁的过期时间 reply = redisCommand(redis_conn, "EXPIRE %s %d", LOCK_KEY, LOCK_EXPIRE_TIME); if (reply == NULL || reply->type == REDIS_REPLY_ERROR || reply->integer != 1) { printf("设置锁的过期时间失败\n"); exit(1); } printf("获取锁成功\n"); // 模拟业务操作 sleep(5); // 释放锁 reply = redisCommand(redis_conn, "DEL %s", LOCK_KEY); if (reply == NULL || reply->type == REDIS_REPLY_ERROR || reply->integer != 1) { printf("释放锁失败\n"); exit(1); } printf("释放锁成功\n"); // 关闭Redis连接 redisFree(redis_conn); exit(0); } else if (child_pid > 0) { // 等待子进程结束 waitpid(child_pid, &status, 0); if (WIFEXITED(status)) { printf("子进程正常结束\n"); } else if (WIFSIGNALED(status)) { printf("子进程异常结束\n"); } } else { printf("创建子进程失败\n"); exit(1); } return 0; } ``` 在这个示例中,使用了 hiredis 库来连接 Redis,并通过 SETNX 和 EXPIRE 命令实现分布式锁的获取和释放。主进程创建一个子进程,子进程尝试获取锁并进行业务操作,然后释放锁。主进程等待子进程的结束并打印相应信息。 注意:这只是一个简单的示例,实际应用中可能需要考虑更多的场景,比如锁的重入、超时处理等。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [分布式锁_Redis分布式锁+Redisson分布式锁+Zookeeper分布式锁+Mysql分布式锁(原版)](https://blog.csdn.net/guan1843036360/article/details/127827270)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值