redis - 实现分布式锁

最新推荐文章于 2024-08-06 20:49:40 发布
最新推荐文章于 2024-08-06 20:49:40 发布
阅读量284 收藏 2
点赞数
分类专栏： Redis 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38946877/article/details/101596528
版权

redis - 实现分布式锁

常用的实现分布式锁的技术：redis、zookeeper、数据库，各种锁的比较如下：

在这里插入图片描述

1，锁的基本概念

1.1 超卖案例：

在这里插入图片描述

1.2 超卖的根源：

在这里插入图片描述

1.3线程安全：

什么是线程安全：
在这里插入图片描述
如何实现线程安全：
在这里插入图片描述
加锁：
如果在方法上增加同步关键字，增加了锁，代码就会变成串行执行，但是代码效率变低了。
在这里插入图片描述

1.4 锁的性能优化：

在这里插入图片描述
1，把同步方法改成同步代码块
2，
3，读锁，写锁分离

1.4 锁的种类：（JVM锁，进程锁）

在这里插入图片描述
独享锁也叫排他锁

2，分布式锁

2.1 分布式环境：

在这里插入图片描述

分布式锁的注意事项：
**加粗样式

redis 分布式锁流程图：
在这里插入图片描述
步骤：
1，竞争锁，判断锁是否存在
如果存在：等待 或者 退出
如果不存在：创建锁，设置锁的有效期，获取锁的线程分配唯一标识

加锁分为三步：
在这里插入图片描述

1，判断锁是否存在
2，如果不存在，加锁
3，设置有效时间

按照以上步骤代码如下：

if（setnx（key，1） == 1）{   //此处挂掉了.....
    expire（key，30）
    try {
        do something ......
    }catch(){
　　}　finally {
       del（key）
    }
}

setnx和expire的非原子性
设想一个极端场景，当某线程执行setnx，成功得到了锁：
setnx刚执行成功，还未来得及执行expire指令，节点1 Duang的一声挂掉了。
这样一来，这把锁就没有设置过期时间，变得“长生不老”，别的线程再也无法获得锁了。

怎么解决呢？setnx指令本身是不支持传入超时时间的，Redis 2.6.12以上版本为set指令增加了可选参数，伪代码如下：set（key，1，30，NX）,这样就可以取代setnx指令。

setnx() 命令只能保证前两个步骤是原子操作。所以在加锁时还是使用set 命令
源码如图所示：set命令有一个nxxx的参数，可以实现setnx() 的功能，又能保证加锁的三步操作都是原子操作。
在这里插入图片描述

解锁分为两步：

在这里插入图片描述

解锁注意事项：超时后使用del 导致误删其他线程的锁

又是一个极端场景，假如某线程成功得到了锁，并且设置的超时时间是30秒。
如果某些原因导致线程B执行的很慢很慢，过了30秒都没执行完，这时候锁过期自动释放，线程B得到了锁。

随后，线程A执行完了任务，线程A接着执行del指令来释放锁。但这时候线程B还没执行完，线程A实际上删除的是线程B加的锁。

怎么避免这种情况呢？可以在del释放锁之前做一个判断，验证当前的锁是不是自己加的锁。

至于具体的实现，可以在加锁的时候把当前的线程ID当做value，并在删除之前验证key对应的value是不是自己线程的ID。

加锁：
String threadId = Thread.currentThread().getId()
set（key，threadId ，30，NX）

doSomething.....
 
解锁：
if（threadId .equals(redisClient.get(key))）{
    del(key)
}

但是，这样做又隐含了一个新的问题，if判断和释放锁是两个独立操作，不是原子性。

因为删除没有原子命令，所以需要借助luau脚本来实现原子删除：

String luaScript = ‘if redis.call(‘get’, KEYS[1]) == ARGV[1] then return redis.call(‘del’, KEYS[1]) else return 0 end’;

redisClient.eval(luaScript , Collections.singletonList(key), Collections.singletonList(threadId));

这样一来，验证和删除过程就是原子操作了。

3，使用redis实现分布式锁，具体代码：

3.1 引入 redis 依赖：

<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.9.0</version>
</dependency>

3.2 解锁的 lua 脚本（可以事先把luau脚本加载到内存中）

if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

3.3 RedisClient：通过redis连接池，获取redis连接

package com.example.redis.lock;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @author h
 * @Description redis 客户端连接池
 * @createTime 2019年09月28日 15:29
 */
public class RedisClient {

    private static final JedisPool POOL;

    static {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(500);
        config.setMaxIdle(5);
        config.setMaxWaitMillis(1000 * 10);
        config.setTestOnBorrow(true);
        POOL = new JedisPool(config, "localhost");
    }

    public static Jedis getClient() {
        return POOL.getResource();
    }
}

3.4 RedisDistributeLock：实现redis分布式锁

package com.example.redis.yunxi_lock;

import redis.clients.jedis.Jedis;

import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @author h
 * @Description 使用redis 实现分布式锁
 * @createTime 2019年09月28日 15:14
 */
public class RedisDistributeLock implements Lock {

    // 锁消息的上下文，保存当前锁的持有人ID
    private ThreadLocal<String> lockContext = new ThreadLocal<>();

    // 默认锁的超时时间
    private long time = 100L;

    private Thread exclusiveOwnerThread;

    @Override
    public void lock() {
        // 类似自旋锁的方式获取锁
        while (!tryLock()) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
        while (!tryLock()) {
            Thread.sleep(100);
        }
    }

    @Override
    public boolean tryLock() {
        return tryLock(time, TimeUnit.MILLISECONDS);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) {
        // 为每个锁的持有人分配唯一的id
        String id = UUID.randomUUID().toString();
        Thread thread = Thread.currentThread();
        Jedis jedis = null;

        try {
            jedis = RedisClient.getClient();
            // 加锁并设置有效期
            boolean getLockSuccess = "OK".equals(jedis.set("yunxi_lock", id, "NX", "PX", unit.toMillis(time)));
            if (getLockSuccess) {
                // 记录锁的持有人id
                lockContext.set(id);
                // 记录当前线程
                setExclusiveOwnerThread(thread);
                return true;
                // 当前线程已经获得了锁，可重入
            } else if (exclusiveOwnerThread == thread) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
        return false;
    }

    private final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    @Override
    public void unlock() {
        String script = null;
        Jedis jedis = RedisClient.getClient();
        try {
            jedis = RedisClient.getClient();
            // 读取lua脚本内容
            script = inputStreamToString(getClass().getResourceAsStream("/redis.script"));
            if (null == lockContext.get()) {
                return;
            }
            // 使用lua脚本，删除锁，通过使用lockContext.get()来确保，谁加的锁，只能有谁来删除
            jedis.eval(script, Arrays.asList("redis_lock"), Arrays.asList(lockContext.get()));
            lockContext.remove();
        }catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    private String inputStreamToString(InputStream in) throws IOException {
        StringBuffer out = new StringBuffer();
        byte[] b = new byte[4096];
        for (int n; (n = in.read(b)) != -1 ; ) {
            out.append(new String(b, 0, n));
        }
        return out.toString();
    }

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

3.5 测试类

package com.example.redis.lock;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author h
 * @Description TODO
 * @createTime 2019年09月28日 17:44
 */
public class RedisLockTest {

    private RedisDistributeLock lock = new RedisDistributeLock();
    // 初始库存数量
    private Integer stock = 8;

    /**
     * 买票减库存操作：未使用锁
     * @param num 购买票数
     */
    private void reduce(int num) {
        if (stock - num >= 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            stock = stock - num;
            System.out.println(Thread.currentThread().getName()
                    + "成功:卖出" + num + "张，库存剩余" + stock + "张票");
            // 后续增加积分的操作
        } else {
            System.out.println(Thread.currentThread().getName()
                    + "失败:库存不足" + num + "张，库存剩余" + stock + "张票");
        }
    }

    /**
     * 买票减库存操作：未使用锁
     * @param num 购买票数
     */
    private void reduceByRedisLock(int num){
        boolean flag = false;
        try {
            lock.lock();
            if (stock - num >= 0) {
                stock -= num;
                flag = true;
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

        if (flag){
            System.out.println(Thread.currentThread().getName()
                    + "成功:卖出" + num + "张，库存剩余" + stock + "张票");
            // 后续增加积分的操作
        } else {
            System.out.println(Thread.currentThread().getName()
                    + "失败:库存不足" + num + "张，库存剩余" + stock + "张票");
        }
    }

    public static void main(String[] args) throws InterruptedException {

        RedisLockTest redisLockTest = new RedisLockTest();

        // 未加锁
//        for (int i = 0; i < 10; i++) {
//            new Thread(() -> redisLockTest.reduce(1), "用户" + (i+1)).start();
//        }

        // 加锁
        for (int i = 0; i < 10; i++) {
            new Thread(() -> redisLockTest.reduceByRedisLock(1), "用户" + (i+1)).start();
        }
        Thread.sleep(1000L);
    }

}

4，使用redis实现分布式锁的注意事项

4.1 出现并发的可能性

还是刚才第二点所描述的场景，虽然我们避免了线程A误删掉key的情况，但是同一时间有A，B两个线程在访问代码块，仍然是不完美的。

怎么办呢？我们可以让获得锁的线程开启一个守护线程，用来给快要过期的锁“续航”。

当过去了29秒，线程A还没执行完，这时候守护线程会执行expire指令，为这把锁“续命”20秒。守护线程从第29秒开始执行，每20秒执行一次。

当线程A执行完任务，会显式关掉守护线程。

另一种情况，如果节点1 忽然断电，由于线程A和守护线程在同一个进程，守护线程也会停下。这把锁到了超时的时候，没人给它续命，也就自动释放了。

5，基于数据库实现分布式锁

在这里插入图片描述

5，基于zookeeper实现分布式锁

准确性高，但性能不如 redis，用于与资金相关的对准确性高要求场景。
在这里插入图片描述
在这里插入图片描述

心之所往、
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redisdistributelock
06-16
分布式系统下，解决系统间锁的问题
Java基于redis实现分布式锁代码实例
08-19
Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...
使用 Redis 实现分布式锁
top_gun_1的专栏
02-17 914
分布式锁是一个在很多环境中非常有用的原语，它是不同进程互斥操作共享资源的唯一方法。有很多的开发库和博客描述如何使用Redis实现DLM（Distributed Lock Manager），但是每个开发库使用不同的方式，而且相比更复杂的设计与实现，很多库使用一些简单低可靠的方式来实现。 这篇文章尝试提供更标准的算法来使用Redis实现分布式锁。我们提出一种算法，叫做Relock，它
4、Redis分布式锁原理解析
qq_29434541的博客
06-30 946
方法用于释放已经持有的锁，确保其他线程可以获取锁。Redisson 通过 Lua 脚本原子性地执行解锁操作，以保证解锁过程的安全性和一致性。方法在获取锁失败时不会一直阻塞，而是根据指定的等待时间和租约时间进行尝试，并返回是否成功获取锁。在等待锁释放期间，Redisson 会进入一个循环，不断尝试重新获取锁。在等待锁释放期间，Redisson 会进入一个循环，不断尝试重新获取锁。如果初次尝试获取锁失败，Redisson 会订阅锁的释放通知。如果初次尝试获取锁失败，Redisson 会订阅锁的释放通知。
Redis实现分布式锁
热门推荐
scorpio的博客
12-28 1万+
Redis实现分布式锁
redis实现分布式锁
玩家六的专栏
02-14 973
使用java自带的lock框架可以很好的解决并发问题，但如果是分布式系统的话，就不能通过这个方法解决并发问题，此时可以使用redis实现并发锁来解决这个问题 使用redis锁有两个重要函数需要介绍 SETNX命令（SET if Not EXists） 语法： SETNX key value 功能： 当且仅当 key 不存在，将 key 的值设为 value ，并返回1；若给
Redis Template实现分布式锁的实例代码
09-09
Redis分布式锁通过`Redis Template`的使用，简化了与Redis的交互，提供了实现分布式锁的基础。但需要注意的是，实现一个完全可靠的分布式锁并不简单，还需要考虑诸如锁续租、公平性、可重入性等问题。在实际项目中，...
人工智能-项目实践-redis-基于 Redis 实现的分布式锁.zip
12-23
人工智能-项目实践-redis-基于 Redis 实现的分布式锁 redis-lock 基于 Redis 实现的分布式锁。要求： Redis >= v7: 理论上来说低于 Redis 7 的也可以，但是暂时我还没在这些 Redis 版本上测试 Go >= 18: 低版本的 ...
记录redisson实现redis分布式事务锁
04-24
首先，Redis作为一个内存数据库，其高速读写性能使其成为实现分布式锁的理想选择。分布式锁的主要作用是在多节点环境下保证同一时刻只有一个节点可以执行特定操作，避免并发问题。Redisson的分布式锁通过`RLock`接口...
redis和zookeeper实现分布式锁的区别
01-20
3. **操作难度**：Redis实现分布式锁较为复杂，需要处理时间计算、锁续期等问题；而Zookeeper通过创建和监听临时节点，实现逻辑更为清晰简单。 总结来说，Redis和Zookeeper在实现分布式锁时各有优缺点。Redis适合对...
如何优雅地用Redis实现分布式锁
weixin_33736048的博客
08-29 320
什么是分布式锁 在学习Java多线程编程的时候，锁是一个很重要也很基础的概念，锁可以看做是多线程情况下访问共享资源的一种线程同步机制。这是对于单进程应用而言的，即所有线程都在同一个JVM进程里的时候，使用Java语言提供的锁机制可以起到对共享资源进行同步的作用。如果分布式环境下多个不同线程需要对共享资源进行同步，那么用Java的锁机制就无法实现了，这个时...
redis 分布式锁
qiyue683209的博客
12-19 230
最近抽空优化了之前已有的redis分布式锁，主要用于解决高并发的问题，比如抢红包，多个人同时操作红包库存，当在库存只剩下1个的时候，一个人的减库存的操作事务没提交，另一个人的查库存操作刚好同步执行，这样就会出现很尴尬的事情，1个红包会被2个人抢走，这个时候，我们就要依托锁，将请求入口锁住，当然锁有很多种方式，这边就记录一下比较好用的redis分布式锁。  方式有很多setNX 、set、incr...
【Redis】分布式锁
最新发布
qq_39921135的博客
08-06 1005
经过上节课的演示，可以发现在集群模式下synchronized锁失效了，synchronized只能保证单个JVM内部的多个线程之间的互斥，而没有办法让我们集群下的多个JVM进程之间互斥，要想解决这个问题，我们必须使用分布式锁。
redis的分布式锁
qiulinsama的博客
12-28 512
Distributed locks with Redis   Distributed locks are a very useful primitive in many environments where different processes must operate with shared resources in a mutually exclusive way.   分布式锁在很多场...
Redis的分布式锁
m0_58524181的博客
09-22 685
Redis的分布式锁
Redis 分布式锁
Reid的专栏
09-13 386
参考： 官方文档 给出的实现 官方文档翻译版 Redis 深度历险：核心原理与应用实践 Redis单节点实现 当resource_name不能存在时才能获取到锁，同时设置超时时间防止出现死锁。这时my_random_value是为了再删除时当前客户端的锁不会被其他客户端删除。 获取锁： SET resource_name my_random_value NX PX 30000 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值