单个Redis实例下的锁正确使用姿势

最新推荐文章于 2024-07-28 18:00:00 发布
最新推荐文章于 2024-07-28 18:00:00 发布
阅读量6.1k 收藏 54
点赞数 9
分类专栏： redis java web 文章标签： redis锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/She_lock/article/details/88894096
版权

一、前言

一年前，写了一篇有瑕疵的博文 Redis分布式锁原理及实现 。这篇博文最后虽然给出了redis实现分布式锁的方式，但是在并发相当高的情况下，比如Requests per second: 1453.85 [#/sec] (mean)情况下，如果出现了一次锁超时，那么，之后的请求会有极大的概率一直持续处在被锁的状态，即出现死锁。
经过不断查资料以及实践检测，最终，得出了Redis使用单个实例下锁的正确实现。

二、原理

有效方式使用分布式锁所需的最低保证：

  • 安全属性：相互排斥。在任何给定时刻，只有一个客户端可以持有锁。
  • 活力属性A：无死锁。最终，即使锁定资源的客户端崩溃或被分区，也始终可以获取锁定。
  • 活力属性B：容错。只要大多数Redis节点启动，客户端就能够获取和释放锁。

由于介绍的是单实例下的Redis锁，所以 活力属性B 暂不考虑。

获得锁定

要获得锁定，可以采用以下方法：

 SET resource_name my_random_value NX PX 30000

该命令仅在密钥尚不存在时才设置密钥（NX选项），到期时间为30000毫秒（PX选项）。密钥设置为“我的随机值”值。此值必须在所有客户端和所有锁定请求中都是唯一的。

以安全的方式释放锁

使用一个告诉Redis的脚本：仅当密钥存在且存储在密钥上的值恰好是我期望的值时才删除密钥。这是通过以下Lua脚本完成的：

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

这一点很重要，以避免删除由另一个客户端创建的锁。仅使用DEL是不安全的，因为客户端可能会删除另一个客户端的锁定。

三、java 实现

老话说得好，Talk is cheap ,show me the code！ 接下来看看其java实现。

导入依赖并配置基础信息

导入依赖：

		<!--  本项目是  springboot 2.0.4.RELEASE 下得实现 -->
     	<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

配置基础信息：

spring:
  redis:
    # Redis数据库索引（默认为0）
    database: 0
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器连接端口
    port: 6379
    # Redis 密码
    password: require_pass
    jedis:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 100
        # 连接池中的最大空闲连接
        max-idle: 500
        # 连接池最大连接数（使用负值表示没有限制）
        max-active: 2000
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 10000
    # 连接超时时间（毫秒）
    timeout: 0

配置JedisPool

新建类RedisConfig如下：


import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;
    
    @Value("${spring.redis.password}")
    private String auth;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;

    @Bean
    public JedisPool redisPoolFactory() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        if(auth ==null || auth.equals("")){
        	return new JedisPool(jedisPoolConfig, host, port, timeout);
        }else{
        	return new JedisPool(jedisPoolConfig, host, port, timeout,auth);
        }
    }

}

核心加锁和解锁方法

创建以下抽象RedisService ：

import cc.mrbird.common.domain.RedisInfo;

import java.util.List;
import java.util.Map;
import java.util.Set;

public interface RedisService {


    /**
     *  setnx expire
     * @param key
     * @param value
     * @param nxxx setnx
     * @param expx expire
     * @param time
     * @return
     */
    String set(String key, String value, String nxxx, String expx, int time);

    /**
     * 执行redis脚本
     * @param script  脚本
     * @param keys 键值
     * @param args 参数
     * @return
     */
    Object eval(String script, List<String> keys, List<String> args);
}

具体实现如下：

@Service("redisService")
public class RedisServiceImpl implements RedisService {

    @Autowired
    JedisPool jedisPool;


    /**
     * 处理jedis请求
     *
     * @param f 处理逻辑，通过lambda行为参数化
     * @return 处理结果
     */
    private Object excuteByJedis(Function<Jedis, Object> f) {
        try (Jedis jedis = jedisPool.getResource()) {
            return f.apply(jedis);
        } catch (Exception e) {
            log.error(e.getMessage());
            return null;
        }
    } 

    @Override
    public String set(String key, String value, String nxxx, String expx, int time) {
        return (String) this.excuteByJedis(j -> j.set(key, value, nxxx, expx, time));
    }

    @Override
    public Object eval(String script, List<String> keys, List<String> args) {
        return this.excuteByJedis(j -> j.eval(script, keys, args));
    }
}

有了以上准备，下面就可以创建一个工具类，专门用来处理Redis锁，如下：

@Component
@Slf4j
public class RedisLockUtils {

    /**
     * 用来表示 setnx 的参数
     */
    private static final String SET_IF_NOT_EXIST = "NX";
    /**
     * EX = seconds（秒）; PX = milliseconds（毫秒）
     */
    private static final String SET_WITH_EXPIRE_TIME = "EX";
    /**
     * 释放锁成功返回值
     */
    private static final Long RELEASE_SUCCESS = 1L;
    /**
     * 加锁成功返回值
     */
    private static final String LOCK_SUCCESS = "OK";
    /**
     * 超时时间 10s，单位是由 {@code SET_WITH_EXPIRE_TIME }
     */
    public static final int TIMEOUT = 10;

    /**
     * 常量前缀
     */
    private static final String REDIS_LOCK_KEY_PREFIX = "redis_lock_key_prefix";

    /**
     * 常量连接符
     */
    private static final String REDIS_LOCK_PLUS = "@";

    /**
     * 可用 key前缀
     */
    public static final String REDIS_LOCK_KEY = REDIS_LOCK_KEY_PREFIX + REDIS_LOCK_PLUS;

    @Autowired
    RedisService redisService;


    /**
     * 生成分布式锁密钥
     *
     * @param key
     * @return
     */
    public String generateLockKey(String key) {
        if (StringUtils.isBlank(key)) {
            return "";
        }
        return REDIS_LOCK_KEY + MD5Utils.encrypt(key);
    }


    /**
     * 尝试获取分布式锁
     *
     * @param lockKey    锁
     * @param requestId  请求标识
     * @param expireTime 超期时间
     * @return 是否获取成功  true：成功获取锁；false：未获取锁资格
     */
    public boolean tryGetDistributedLock(String lockKey, String requestId, int expireTime) {

        String result = redisService.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);

        if (LOCK_SUCCESS.equals(result)) {
            return true;
        }
        return false;
    }

    /**
     * 释放分布式锁
     *
     * @param lockKey   锁
     * @param requestId 请求标识
     * @return 是否释放成功  true：手动解锁成功；false：手动解锁失败
     */
    public boolean releaseDistributedLock(String lockKey, String requestId) {

        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Object result = redisService.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));
        if (RELEASE_SUCCESS.equals(result)) {
            return true;
        }
        log.info("解锁失败，解锁用户：{}， 锁值为：{}", requestId, lockKey);
        return false;
    }

}

到这，就可以愉快得撸代码了。

四、拓展

以上方法实现的redis锁，每次只有一个用户占用锁资源，这样会照成当一个用户A获取锁执行业务逻辑时，其他的用户都不能执行这块的业务逻辑，只有当A执行完成后，其他用户再次请求过来时，才有机会和获取到锁资格去执行相应的业务逻辑。

下面我有一个业务场景，比如发红包，如果用上面这样的锁机制，先点击“抢红包”按钮的用户，也不一定能比后点击“抢红包”按钮的用户先抢到红包。因为先点击的用户可能此时锁正被占用，而后点击的后点击的用户 可能这时候锁正好释放被他给碰上了。所以这样情况，以上的锁机制是不符合这个抢红包的逻辑的。

那么应该怎么办呢？？？其实也很简单。利用redis的单线程特性和其api中的 DECR 或是INCR可以实现。

下面来看一看基础 命令：

INCR key

简述：

  • 为键 key 储存的数字值加上一。

  • 如果键 key 不存在， 那么它的值会先被初始化为 0 ， 然后再执行 INCR 命令。

  • 如果键 key 储存的值不能被解释为数字， 那么 INCR 命令将返回一个错误。

  • 本操作的值限制在 64 位(bit)有符号数字表示之内。

  • INCR 命令是一个针对字符串的操作。 因为 Redis 并没有专用的整数类型， 所以键 key 储存的值在执行 INCR 命令时会被解释为十进制 64 位有符号整数。

返回值： INCR 命令会返回键 key 在执行加一操作之后的值。

代码示例：

redis> SET page_view 20
OK

redis> INCR page_view
(integer) 21

redis> GET page_view    # 数字值在 Redis 中以字符串的形式保存
"21"

DECR key

简述：

  • 为键 key 储存的数字值减去一。

  • 如果键 key 不存在， 那么键 key 的值会先被初始化为 0 ， 然后再执行 DECR 操作。

  • 如果键 key 储存的值不能被解释为数字， 那么 DECR 命令将返回一个错误。

  • 本操作的值限制在 64 位(bit)有符号数字表示之内。

返回值： DECR 命令会返回键 key 在执行减一操作之后的值。

代码示例：
对储存数字值的键 key 执行 DECR 命令：

redis> SET failure_times 10
OK

redis> DECR failure_times
(integer) 9

对不存在的键执行 DECR 命令：

redis> EXISTS count
(integer) 0

redis> DECR count
(integer) -1

测试

在上面的RedisServiceImpl 类中添加一个方法：

    public Long incr(String key) {
        return (Long)this.excuteByJedis(j -> j.incr(key));
    }

测试方法逻辑如下：

    public String testIncr() {
        long tmp = 0;
        if ((tmp = redisService.incr("numkey")) > 100) {  //100是红包数量，假定限制只能 发100个

            return "已经发完了！！！";
        }

        System.out.println("第" + tmp + “抢到红包的幸运儿！”) ;
        return "成功发出一个红包！";
    }

这样处理后，那么可以保证先点击的前一百个用户可以抢到红包，后面点击的用户则不会抢到红包了。

ps:你也可以使用 DECR 执行减法操作来计数，同时还可以利用set方法设置一个初值，并给定一个红包过期时间，留给读者发挥，这里就不赘述了。

参考文档：

She_lock
关注
专栏目录
Redis 作者 Antirez 讲如何实现分布式锁？Redis 实现分布式锁天然的缺陷分析&Redis分布式锁的正确使用姿势！...
程序员光剑
11-11 8535
Redis分布式锁基本原理采用 redis 实现分布式锁，主要是利用其单线程命令执行的特性，一般是 setnx， 只会有一个线程会执行成功，也就是只有一个线程能成功获取锁；看着很完美。然而——看看可能有什么问题？一般生产环境为了可用性，redis 会部署 master-slave + sentinel 的结构， 如：master 提供服务、slave standby 作为备份节点不提供服务， ma...
Redis分布式锁的原理以及如何续期
热门推荐
击水三千里的专栏
03-11 3万+
redis 分布式锁的原理
Redis的锁
Xueyuanxi1229的博客
10-29 628
场景2(多线程操作),我有100元,另外一个人0元,我给另外一个人转20,这时候我工资到账我的钱发送改动watch会告诉事务我的钱发生变化，所有的事务都会操作失败。很悲观,认为什么时候都会出问题,无论做什么(操作)都会加锁(这种情况会非常影响性能,无论干什么都会加锁,用完之后再去解锁)4 对监视的值有没有发生变化,如果没有变化,那么可以执行成功，如果发生变化就会执行失败,然后重新解锁再获取最新的锁。场景1(单线程操作),我有100元,另外一个人0元,我给另外一个人转20,我剩80,他有20。
redis 锁
qq_33854869的博客
07-04 426
项目中经常使用到redis锁,锁最常用的场景在多线程操作共享资源时,需要对共享资源进行加锁,避免造成重复处理或处理时数据已经是脏数据.多个线程使用同一个锁,也就是锁必须独立与这些线程之外(也可以使用线程直接变量共享,用的少),在一个独立的应用中,锁可以直接存储在应用上,这样这个应用的其他线程都可以获取到,但是一旦牵扯到多个应用以分布式的形式存在,这就需要分布式锁,而redis锁就是一种应用很广泛的
Redis-分布式锁
最新发布
m0_71386740的博客
07-28 1172
基于Redis的分布式锁实现思路：利用set nx ex获取锁，并设置过期时间，保存线程标示释放锁时先判断线程标示是否与自己一致，一致则删除锁特性：利用set nx满足互斥性利用set ex保证故障时锁依然能释放，避免死锁，提高安全性利用Redis集群保证高可用和高并发特性利用lua脚本确保一致性分布式锁-redission重入问题。
springboot整合redis实现分布锁
domcj的博客
03-07 913
首先在pom.xml中加入需要的redis依赖和缓存依赖 &lt;!-- 引入redis依赖 --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifact...
redis几种加锁的实现
weixin_30355437的博客
12-31 2296
1. redis加锁分类 redis能用的的加锁命令分表是INCR、SETNX、SET 2. 第一种锁命令INCR 这种加锁的思路是， key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作进行加一。然后其它用户在执行 INCR 操作进行加一时，如果返回的数大于 1 ，说明这个锁正在被使用当中。 1、 客户端A请求服务器获取key的值为1表...
redis锁
2301_78008478的博客
06-17 4069
具体场景，进程1在超时释放了锁之后，进程2获取到了锁，后来进程1又释放锁，如此以来就有可能导致进程2没有完成就被进程1释放了锁。会设置主从，主从服务器中的从服务器在检测到主服务器挂掉之后，就会重新选举一个作为主服务器，而redis锁是操作在主服务器上的。这个场景，是非常基本的场景，一旦锁被进程1获取之后，在释放锁之前，进程2是怎么知道何时才能够获取到锁呢？这个场景与场景2是一个问题的延伸，一旦我们在设置锁的超时时间过短，就会发生这个情况。针对这种问题，我们其实没有太好的办法，不过还好这种数据的概率比较低。
redis锁redis锁
10-12
redis-jedis-2.4.1_lock.zip redis锁
redis之锁
youhebuke225的博客
05-21 1628
redis 中的所分为悲观锁和乐观锁 一个例子 银行账户一共有10000元 三个客户在三个取款机上操作 A客户想取7000 B客户想取5000 C客户想取3000 悲观锁 在悲观锁的观点下，每一次操作都会修改数据，所以每一次拿数据的时候都会上锁 也就是说在悲观锁的情况下，这三个客户是不允许在三个取款机上操作的，只能在一个取款机上操作 因为当有一个客户在唯一的一台取款机上操作的时候，其他客户是不能操作的(不能动这比存款) 乐观锁 在乐观锁的观点下，每一次操作都不会修改数据，所以不会上.
【redis】redis 锁
十一月的肖邦
12-02 3626
本文围绕 redis 的SETNX命令展开对“锁”的研究与实现。多个进程同时对 redis 执行命令，只有一个进程会成功，其余都会失败。上述命令中的代表被当作锁的 redis 键名，其类型为 String，代表该键的过期时间戳，下同。
Redis锁 - RedLock
栀子花开几百度的博客
11-30 2329
redis提供了一个分布式锁的规范算法 Redlock java版本：Redisson ：https://github.com/redisson/redisson 锁的特点：独享（互斥）、无死锁（持有锁的客户端崩溃或者网络分裂，锁仍然可以使用）、容错（大部分节点活着可用） 第一个阶段： redis设置锁，就是创建一个key，然后针对整个key设置过期时间，执行完，删除这个key，这里面有个问题，redis挂了怎么办？增加一个从节点？redis的主从是异步的，如果主挂了，还是有问题。（客户端A从..
Redis锁-Redisson
bigben
12-25 983
Redisson作为java的Redis客户端之一，是Redis官网推荐的java语言实现分布式锁的项目。Redisson就是提供了一堆锁...也是目前大部分公司使用Redis分布式锁最常用的一种方式。
使用Redis锁
Hcode4的博客
09-28 335
使用Redis锁 配置redisClient 获取redis集群地址 Config config = new Config(); Config.useCluterServices().addNodeAddress(nodeArr); return Redis.create(config); redissonClient 使用 Rlock rlock = redissonClien...
Redis入门（七）：Redis分布式锁（单机模式/集群模式）
Haiyoung
10-13 9754
Redis 实现分布式锁 单机模式的Redis分布式锁 集群模式的Redis分布式锁 Redlock Redis 实现分布式锁 单机模式的Redis分布式锁 优缺点 实现比较轻，大多数时候能满足需求；因为是单机单实例部署，如果redis服务宕机，那么所有需要获取分布式锁的地方均无法获取锁，将全部阻塞，需要做好降级处理。 当锁过期后，执行任务的进程还没有执行完，但是锁因为自动过期已...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值