Redis——》分布式锁

最新推荐文章于 2023-04-21 20:37:04 发布
最新推荐文章于 2023-04-21 20:37:04 发布
阅读量237 收藏 1
点赞数
分类专栏： Redis 文章标签： redis 分布式锁 lock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43453386/article/details/112863436
版权

参考：
Redis命令
Redis命令

1、分布式锁应满足的四个条件

  • 互斥性。在任意时刻，只有一个客户端能持有锁。
  • 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
  • 容错性。只要大部分的Redis节点正常运行，客户端就可以加锁和解锁。
  • 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

2、Redis流程图

在这里插入图片描述

3、pom依赖

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

4、lua脚本示例

1）获取锁

local key = KEYS[1]
local value = ARGV[1] 
local expireTime = ARGV[2]
if (redis.call('setnx',key,value) == 1) then
   redis.call('pexpire' , key , expireTime)
   return 'true'
else 
   return 'false'
end

2）延长锁

local key = KEYS[1]
local value = ARGV[1] 
local newExpireTime = ARGV[2]
if (redis.call('get',key) == value)  then
   redis.call('pexpire' , key ,newExpireTime)
   return 'true'
else 
   return 'false'
end

3）释放锁

local key = KEYS[1]
local value = ARGV[1] 
if (redis.call('get',key) == value)  then
   redis.call('del' , key ) 
   return 'true'
else 
   return 'false'
end

5、java示例

import lombok.Data;
import lombok.experimental.Accessors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.commands.JedisCommands;
import redis.clients.jedis.params.SetParams;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.UUID;

/**
 * Redis分布式锁
 * 使用 SET resource-name anystring NX EX max-lock-time 实现
 * <p>
 * 从 Redis 2.6.12 开始 SET 提供的新特性，
 * 命令 SET key value [EX seconds] [PX milliseconds] [NX|XX]，其中：
 * <p>
 * EX seconds      — 设置 key 的过期时间：以秒为单位
 * PX milliseconds — 设置 key 的过期时间：以毫秒为单位
 * NX              — 将key 的值设为value ，当且仅当key 不存在，等效于 SETNX。
 * XX              — 将key 的值设为value ，当且仅当key 存在，等效于 SETEX。
 * <p>
 * 命令 SET resource-name anystring NX EX max-lock-time 是一种在 Redis 中实现锁的简单方法。
 * <p>
 * 客户端执行以上的命令：
 * <p>
 * 如果服务器返回 OK ，那么这个客户端获得锁。
 * 如果服务器返回 NIL ，那么客户端获取锁失败，可以在稍后再重试。
 * <p>
 * Created with IntelliJ IDEA.
 *
 * @author: xiaoxian
 * @since: 2019/12/10 10:13
 */
@Slf4j
@Data
@Accessors(chain = true)
public class RedisLock {

    private StringRedisTemplate redisTemplate;

    /**
     * 将key 的值设为value ，当且仅当key 不存在，等效于 SETNX
     */
    public static final String NX = "NX";

    /**
     * 设置 key 的过期时间：以秒为单位seconds，等效于EXPIRE key seconds
     */
    public static final String EX = "EX";

    /**
     * 调用set后的返回值
     */
    public static final String OK = "OK";

    /**
     * 默认请求锁的超时时间：ms 毫秒
     */
    private static final long TIME_OUT = 100;

    /**
     * 默认锁的有效时间：s 秒
     */
    public static final int EXPIRE = 60;

    /**
     * 解锁的lua脚本
     */
    public static final String UNLOCK_LUA;

    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();
    }

    /**
     * 锁标志对应的key
     */
    private String lockKey;

    /**
     * 记录到日志的锁标志对应的key
     */
    private String lockKeyLog = "";

    /**
     * 锁对应的值
     */
    private String lockValue;

    /**
     * 锁的有效时间：s秒
     */
    private int expireTime = EXPIRE;

    /**
     * 请求锁的超时时间：ms毫秒
     */
    private long timeOut = TIME_OUT;

    /**
     * 锁标记
     */
    private volatile boolean locked = false;

    final Random random = new Random();

    /**
     * 使用默认的锁过期时间和请求锁的超时时间
     *
     * @param redisTemplate
     * @param lockKey       锁的key（Redis的Key）
     */
    public RedisLock(StringRedisTemplate redisTemplate, String lockKey) {
        this.redisTemplate = redisTemplate;
        this.lockKey = lockKey + "_lock";
    }

    /**
     * 使用默认的请求锁的超时时间，指定锁的过期时间
     *
     * @param redisTemplate
     * @param lockKey       锁的key（Redis的Key）
     * @param expireTime    锁的过期时间(单位：秒)
     */
    public RedisLock(StringRedisTemplate redisTemplate, String lockKey, int expireTime) {
        this(redisTemplate, lockKey);
        this.expireTime = expireTime;
    }

    /**
     * 使用默认的锁的过期时间，指定请求锁的超时时间
     *
     * @param redisTemplate
     * @param lockKey       锁的key（Redis的Key）
     * @param timeOut       请求锁的超时时间(单位：毫秒)
     */
    public RedisLock(StringRedisTemplate redisTemplate, String lockKey, long timeOut) {
        this(redisTemplate, lockKey);
        this.timeOut = timeOut;
    }

    /**
     * 锁的过期时间和请求锁的超时时间都是用指定的值
     *
     * @param redisTemplate
     * @param lockKey       锁的key（Redis的Key）
     * @param expireTime    锁的过期时间(单位：秒)
     * @param timeOut       请求锁的超时时间(单位：毫秒)
     */
    public RedisLock(StringRedisTemplate redisTemplate, String lockKey, int expireTime, long timeOut) {
        this(redisTemplate, lockKey, expireTime);
        this.timeOut = timeOut;
    }

    /**
     * 尝试获取锁 超时返回
     *
     * @return
     */
    public boolean tryLock() {
        // 生成随机key
        lockValue = UUID.randomUUID().toString();
        // 请求锁超时时间，纳秒
        long timeout = timeOut * 1000000;
        // 系统当前时间，纳秒
        long nowTime = System.nanoTime();
        while ((System.nanoTime() - nowTime) < timeout) {
            if (OK.equalsIgnoreCase(this.set(lockKey, lockValue, expireTime))) {
                locked = true;
                // 上锁成功结束请求
                return true;
            }

            // 每次请求等待一段时间
            seleep(10, 50000);
        }
        return locked;
    }

    /**
     * 尝试获取锁 立即返回
     *
     * @return 是否成功获得锁
     */
    public boolean lock() {
        lockValue = UUID.randomUUID().toString();
        //不存在则添加 且设置过期时间（单位ms）
        String result = set(lockKey, lockValue, expireTime);
        locked = OK.equalsIgnoreCase(result);
        return locked;
    }

    /**
     * 以阻塞方式的获取锁
     *
     * @return 是否成功获得锁
     */
    public boolean lockBlock() {
        lockValue = UUID.randomUUID().toString();
        while (true) {
            //不存在则添加 且设置过期时间（单位ms）
            String result = set(lockKey, lockValue, expireTime);
            if (OK.equalsIgnoreCase(result)) {
                locked = true;
                return locked;
            }

            // 每次请求等待一段时间
            seleep(10, 50000);
        }
    }

    /**
     * 解锁
     * <p>
     * 可以通过以下修改，让这个锁实现更健壮：
     * <p>
     * 不使用固定的字符串作为键的值，而是设置一个不可猜测（non-guessable）的长随机字符串，作为口令串（token）。
     * 不使用 DEL 命令来释放锁，而是发送一个 Lua 脚本，这个脚本只在客户端传入的值和键的口令串相匹配时，才对键进行删除。
     * 这两个改动可以防止持有过期锁的客户端误删现有锁的情况出现。
     */
    public Boolean unlock() {
        // 只有加锁成功并且锁还有效才去释放锁
        if (locked) {
            try {
                return redisTemplate.execute((RedisConnection connection) -> {
                    Object nativeConnection = connection.getNativeConnection();
                    Long result = 0L;

                    List<String> keys = new ArrayList<>();
                    keys.add(lockKey);
                    List<String> values = new ArrayList<>();
                    values.add(lockValue);

                    // 集群模式
                    if (nativeConnection instanceof JedisCluster) {
                        result = (Long) ((JedisCluster) nativeConnection).eval(UNLOCK_LUA, keys, values);
                    }

                    // 单机模式
                    if (nativeConnection instanceof Jedis) {
                        result = (Long) ((Jedis) nativeConnection).eval(UNLOCK_LUA, keys, values);
                    }

                    if (result == 0 && !StringUtils.isEmpty(lockKeyLog)) {
                        log.debug("Redis分布式锁，解锁{}失败！解锁时间：{}", lockKeyLog, System.currentTimeMillis());
                    }

                    locked = result == 0;
                    return result == 1;
                });
            } catch (Throwable e) {
                log.warn("Redis不支持EVAL命令，使用降级方式解锁：{}", e.getMessage());
                String value = this.get(lockKey, String.class);
                if (lockValue.equals(value)) {
                    redisTemplate.delete(lockKey);
                    return true;
                }
                return false;
            }
        }

        return true;
    }

    /**
     * 获取锁状态
     *
     * @return
     * @Title: isLock
     * @author yuhao.wang
     */
    public boolean isLock() {

        return locked;
    }

    /**
     * 重写redisTemplate的set方法
     * <p>
     * 命令 SET resource-name anystring NX EX max-lock-time 是一种在 Redis 中实现锁的简单方法。
     * <p>
     * 客户端执行以上的命令：
     * <p>
     * 如果服务器返回 OK ，那么这个客户端获得锁。
     * 如果服务器返回 NIL ，那么客户端获取锁失败，可以在稍后再重试。
     *
     * @param key     锁的Key
     * @param value   锁里面的值
     * @param seconds 过去时间（秒）
     * @return
     */
    private String set(final String key, final String value, final long seconds) {
        Assert.isTrue(!StringUtils.isEmpty(key), "key不能为空");
        return redisTemplate.execute((RedisConnection connection) -> {
            Object nativeConnection = connection.getNativeConnection();
            String result = null;
            if (nativeConnection instanceof JedisCommands) {
                result = ((JedisCommands) nativeConnection).set(key, value, SetParams.setParams().nx().ex((int) seconds));
            }
            if (nativeConnection instanceof JedisCluster) {
                result = ((JedisCluster) nativeConnection).set(key, value, SetParams.setParams().nx().ex((int) seconds));
            } else {
                log.error("nativeConnection error");
            }

            if (!StringUtils.isEmpty(lockKeyLog) && !StringUtils.isEmpty(result)) {
                log.info("获取锁{}的时间：{}", lockKeyLog, System.currentTimeMillis());
            }

            return result;
        });
    }

    /**
     * 获取redis里面的值
     *
     * @param key    key
     * @param aClass class
     * @return T
     */
    private <T> T get(final String key, Class<T> aClass) {
        Assert.isTrue(!StringUtils.isEmpty(key), "key不能为空");
        return redisTemplate.execute((RedisConnection connection) -> {
            Object nativeConnection = connection.getNativeConnection();
            Object result = null;
            if (nativeConnection instanceof JedisCommands) {
                result = ((JedisCommands) nativeConnection).get(key);
            }
            if (nativeConnection instanceof JedisCluster) {
                result = ((JedisCluster) nativeConnection).get(key);
            }
            return (T) result;
        });
    }


    /**
     * @param millis 毫秒
     * @param nanos  纳秒
     * @Title: seleep
     * @Description: 线程等待时间
     * @author yuhao.wang
     */
    private void seleep(long millis, int nanos) {
        try {
            Thread.sleep(millis, random.nextInt(nanos));
        } catch (InterruptedException e) {
            log.info("获取分布式锁休眠被中断：", e);
        }
    }

}
小仙。
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
实现Redis分布式锁
芒果不是程序猿v：lemon-hanwa 的博客
03-30 170
前言 在面试中经常会被面试官问到Redis分布式锁,随着用户量和业务的增加,传统的单体架构已经无法满足我们的业务需求,这时候单体架构项目的必须升级为分布式、集群、微服务。分布式项目能带来性能上的提升，但分布式环境和集群环境下，存在数据一致性的问题。在分布式项目中,因为分布式和集群是部署到不同的服务器，线程资源不能共享,传统的锁已经无法满足我们的需求了，这时候就需要分布式锁。特别是那些具有高并发分...
redis——分布式锁.zip
09-22
本资源包 "redis——分布式锁.zip" 提供了关于如何在 Redis 中实现分布式锁的相关内容。 分布式锁是一种在多节点之间协调访问共享资源的机制，确保同一时刻只有一个客户端能够访问特定资源。Redis 分布式锁基于其...
扩展redisTemplate实现分布式锁
dgqvhtlwq472235338的博客
08-28 131
原文：https://blog.csdn.net/qq1010267837/article/details/79697572 依赖jar包 compile group: 'redis.clients', name: 'jedis', version:'2.8.1'compile group: 'org.springframework.data', name: 'spring-d...
redisTemplate分布式锁演变、redission分布式锁实现！
Java知音
07-12 226
点击关注公众号，实用技术文章及时了解来源：blog.csdn.net/zhangkaixuan456/article/details/110679617分布式锁的演进基本原理我们可以同时去...
RedisTemplate实现分布式锁
热门推荐
weixin_38399962的博客
09-18 3万+
使用Redis的SETNX命令获取分布式锁的步骤： C1和C2线程同时检查时间戳获取锁，执行SETNX命令并都返回0，此时锁仍被C3持有，并且C3已经崩溃 C1 DEL锁 C1 使用SETNX命令获取锁，并且成功 C2 DEL锁 C2 使用SETNX命令获取锁，并且成功 ERROR : 由于竞态条件，C1和C2都获取到了锁 幸运的是，以下面的步骤完全可以避免这种情况发生，看看C4线程如...
php redis setnx分布式锁简单原理解析
12-16
2. **使用`Redlock`算法**：Redlock是由Redis作者Antirez提出的一种更健壮的分布式锁算法，它通过在多个Redis实例上获取锁，并且只有当在大多数实例上都成功时才认为获取锁成功。 3. **处理锁的续订**：如果持有锁的...
redis分布式 —— 客户端库tinyredis1
08-03
《Redis分布式——客户端库tinyredis1详解》 在分布式系统中，Redis作为一种高性能的键值存储服务，常被用来构建高效的数据存储和缓存解决方案。本文将重点介绍一种名为tinyredis的客户端库，它是实现Redis分布式...
Java架构直通车——用Redis实现分布式会话
01-20
【分布式会话与Redis实现】 在现代Web应用中，随着业务规模的扩大，单体架构逐渐演变为分布式架构，这带来了更高的并发处理能力和系统扩展性。然而，分布式环境下的会话管理成为了一个挑战，因为传统的基于内存的...
基于Redis实现分布式应用限流的方法
08-28
以下是一个基于Redis的分布式限流实现，利用了Redis的数据结构——有序集合（Sorted Set）来创建令牌桶算法的一个变体： ```java public class RedisRateLimiter { private static final String BUCKET = "BUCKET...
redisTemplate封装成redisUtils和分布式锁实现
06-18
redisTemplate封装成redisUtils和分布式锁实现,亲测可用
redisTemplate 实现分布式锁 (windows版redis)
萌神30号 ↝
04-06 433
一 安装windows版本redis https://github.com/microsoftarchive/redis/releases 二 代码
RedisTemplate分布式锁实现
whatzhang007的博客
09-02 453
private static final Long LOCK_SUCCESS = 1L; private static final String TRY_LOCK_SCRIPT = "if redis.call('setNx',KEYS[1],ARGV[1]) then if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('expire',KEYS[1],ARGV[2]) else return 0 end end"; private s
使用RedisTemplat实现简单的分布式锁
weixin_45826772的博客
11-18 730
不使用redisson框架实现Redis分布式锁 准备工作： 导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 编写RedisConfig类 @Configuration public class Re
redistemplate分布式锁实现_Redis实现分布式文件夹锁
weixin_39656686的博客
12-08 312
缘起最近做一个项目，类似某度云盘，另外附加定制功能，本人负责云盘相关功能实现，这个项目跟云盘不同的是，以项目为分配权限的单位，同一个项目及子目录所有有权限的用户可以同时操作所有文件，这样就很容易出现并发操作，而且表结构设计的时候，定下来文件和文件夹都有个path字段，存储的是所在父级文件夹路径，这样检索方便，重命名和移动比较麻烦。如下，例如甲同学正在移动项目下C文件夹，而此时乙同学也在操作项目下D...
记一次RedisTemplate实现分布式锁
weixin_42999287的博客
08-23 222
添加分布式锁 /** * 添加分布式锁 * * @param key：key * @param value：value用于解锁 * @return boolen */ private boolean getLock(String key, String value) { Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent(key, value, 60,
基于RedisTemplate实现简单redis分布式锁
kd_bright的博客
04-21 440
【代码】基于RedisTemplate实现简单redis分布式锁。
Redis之分布式锁的实现
程铭程铭你快成名的博客
07-01 1万+
分布式锁在分布式系统中比较常见，常见的分布式锁解决方案有： zookeeper，创建顺序临时节点来实现 redis实现（setnx / setnx命令） 数据库唯一主键 这篇文章主要介绍下redis分布式锁怎么实现。在了解分布式锁的实现之前，我们需要了解下分布式锁应该注意些什么： 互斥性，即任何时刻都是一个客户端持有锁 避免死锁，一个客户端挂掉之后不能释放锁，导致后面的客户端不能加锁 保证加锁和解锁是同一个客户端 只要大部分的Redis节点正常运行，客户端就可以进行加锁和解锁操作 废话不多说，直接上
springboot集成 redis分布式锁
最新发布
07-30
回答: 在Spring Boot中集成Redis分布式锁可以使用Redisson来实现。Redisson是一个基于Redis的分布式对象和服务框架，内部已经实现了Redis的分布式锁，使用起来更加方便和稳定。通过Redisson，可以使用RedLock算法来实现分布式锁，确保锁的正确性和可靠性。在Redis集群环境下，可能存在锁失效或死锁的问题，但使用Redisson的分布式锁可以解决这个问题。此外，分布式锁是为了解决分布式系统中控制共享资源访问的问题，因为在分布式系统中，多线程、多进程分布在不同机器上，传统的并发控制锁策略失效。因此，通过集成Redis分布式锁，可以有效地控制共享资源的访问。 #### 引用[.reference_title] - *1* *2* [springboot集成redis 分布式锁(redistemplate,lua,redisson)](https://blog.csdn.net/jun2571/article/details/130382023)[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^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [Springboot集成Redis——实现分布式锁](https://blog.csdn.net/tang_seven/article/details/126769580)[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^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值