首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >java架构之路-(Redis专题)简单聊聊redis分布式锁

java架构之路-(Redis专题)简单聊聊redis分布式锁

作者头像
小菜的不能再菜
发布2019-10-29 10:47:26
3430
发布2019-10-29 10:47:26
举报
文章被收录于专栏:java_pythonjava_python

  这次我们来简单说说分布式锁,我记得过去我也过一篇JMM的内存一致性算法,就是说拿到锁的可以继续操作,没拿到的自旋等待。

思路与场景

  我们在Zookeeper中提到过分布式锁,这里我们先用redis实现一个简单的分布式锁,这里是我们一个简单的售卖减库存的小实例,剩余库存假设存在数据库内。

@GetMapping(value = "/getLock")
public String getLock() {
    int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
    if (stock > 0) {
        int realStock = stock - 1;
        stringRedisTemplate.opsForValue().set("stock", realStock + "");
        System.out.println("售卖成功,剩余" + realStock + "");
        return "success";
    }else{
        System.out.println("剩余库存不足");
        return "fail";
    }
}

  这样简单的实现了一个售卖的过程,现在看来确实没什么问题的,但是如果是一个并发下的场景就可能会出现超卖的情况了,我们来改造一下代码。

@GetMapping(value = "/getLock")
public String getLock() {
    synchronized (this) {
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if (stock > 0) {
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock", realStock + "");
            System.out.println("售卖成功,剩余" + realStock + "");
            return "success";
        } else {
            System.out.println("剩余库存不足");
            return "fail";
        }
    }
}

  貌似这回就可以了,可以抗住高并发了,但是新的问题又来了,我们如果是分布式的场景下,synchronized关键字是不起作用的啊。也就是说还是会出现超卖的情况的啊,我们再来改造一下

@GetMapping(value = "/getLock")
public String getLock() {
    String lockKey = "lock";

    Boolean bool = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "xiaocai");//相当于我们的setnx命令
    if(!bool){
        return "error";
    }

    int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
    if (stock > 0) {
        int realStock = stock - 1;
        stringRedisTemplate.opsForValue().set("stock", realStock + "");
        System.out.println("售卖成功,剩余" + realStock + "");
        stringRedisTemplate.delete(lockKey);
        return "success";
    } else {
        System.out.println("剩余库存不足");
        stringRedisTemplate.delete(lockKey);
        return "fail";
    }
}

  这次我们看来基本可以了,使用我们的setnx命令来做一次唯一的限制,万一报错了呢?解锁怎么办?再来改造一下。

@GetMapping(value = "/getLock")
public String getLock() {
    String lockKey = "lock";
    Boolean bool = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "xiaocai", 10, TimeUnit.SECONDS);//相当于我们的setnx命令
    try {
        if (!bool) {
            return "error";
        }

        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if (stock > 0) {
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock", realStock + "");
            System.out.println("售卖成功,剩余" + realStock + "");

            return "success";
        } else {
            System.out.println("剩余库存不足");
            return "fail";
        }
    } finally {
        if (bool) {
            stringRedisTemplate.delete(lockKey);
        }
    }
}

    这次貌似真的可以了,可以加锁,最后在finally解锁,如果解锁还是不成功,我们还设置了我们的超时时间,貌似完美了,我们再来提出一个场景。

  就是什么意思呢?我们的线程来争抢锁,拿到锁的线程开始执行,但是我们并不知道何时执行完成,我们只是设定了10秒自动释放掉锁,如果说我们的线程10秒还没有结束,其它线程会拿到锁资源,开始执行代码,但是过了一段时间(蓝色线程还未执行完成),这时我们的绿色线程执行完毕了,开始释放锁资源,他释放的其实已经不是他自己的锁了,他自己的锁超时了,自动释放了,实则绿色线程释放的蓝色的资源,这也就造成了释放其它的锁,其它的线程又会重复的拿到锁,重复执行该操作。明显有点乱了,这不合理,我们来改善一下。

@GetMapping(value = "/getLock")
public String getLock() {
    String lockKey = "lock";
    String lockValue = UUID.randomUUID().toString();
    Boolean bool = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, lockValue, 10, TimeUnit.SECONDS);//相当于我们的setnx命令
    try {
        if (!bool) {
            return "error";
        }

        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if (stock > 0) {
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock", realStock + "");
            System.out.println("售卖成功,剩余" + realStock + "");

            return "success";
        } else {
            System.out.println("剩余库存不足");
            return "fail";
        }
    } finally {
        if (lockValue.equals(stringRedisTemplate.opsForValue().get(lockKey))) {
            stringRedisTemplate.delete(lockKey);
        }
    }
}

  这次再来看一下流程,我们设置一个UUID,设置为锁的值,也就是说,每次上锁的UUID都是不一致的,我们的线程A的锁这次只能由我们的线程A来释放掉,不会造成释放其它锁的问题了,还是上次的图,我们回过头来看一下,10秒?真的合理吗?万一10秒还没有执行完成呢?有的人还会问,那设置100秒?万一执行到delete操作的时候,服务宕机了呢?是不是还要等待100秒才可以释放锁。别说那只是万一,我们的代码希望达到我们能力范围之内的最严谨。这次来说一下我们本节的其中一个重点,Lua脚本,后面会去说,我们来先用我们这次博文的Redisson吧

Redisson

  刚才我们提到了我们锁的时间设置,多长才是合理的,100秒?可能宕机,造成等待100秒自动释放,1秒?线程可能执行不完,我们可不可以这样来做呢?我们设置一个30秒,或者说设置10秒,然后我们给予一个固定时间来检查我们的主线程是否执行完成,执行完成再释放我们的锁,思路有了,但是代码实现起来并不简单,别着急,我们已经有了现成的包供我们使用的,就是我们的Redisson,首先我们来引入我们的依赖,修改一下pom文件。

<!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.11.4</version>
</dependency>

然后通过@Bean的方式注入容器,三种方式我都写在上面了。

@Bean
public Redisson redisson(){
    Config config = new Config();
    //主从(单机)
    config.useSingleServer().setAddress("redis://127.0.0.1:6379").setDatabase(0);
    //哨兵
//    config.useSentinelServers().setMasterName("mymaster");
//    config.useSentinelServers().addSentinelAddress("redis://192.168.1.1:26379");
//    config.useSentinelServers().addSentinelAddress("redis://192.168.1.2:26379");
//    config.useSentinelServers().addSentinelAddress("redis://192.168.1..3:26379");
//    config.useSentinelServers().setDatabase(0);
//    //集群
//    config.useClusterServers()
//            .addNodeAddress("redis://192.168.0.1:8001")
//            .addNodeAddress("redis://192.168.0.2:8002")
//            .addNodeAddress("redis://192.168.0.3:8003")
//            .addNodeAddress("redis://192.168.0.4:8004")
//            .addNodeAddress("redis://192.168.0.5:8005")
//            .addNodeAddress("redis://192.168.0.6:8006");
//    config.useSentinelServers().setPassword("xiaocai");//密码设置
    return (Redisson) Redisson.create(config);
}

如果我们的是springboot也可以通过配置来实现的。

application.properties

## 因为springboot-data-redis 是用到了jedis,所已这里得配置
spring.redis.database=10
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
## jedis 哨兵配置
spring.redis.sentinel.master=mymaster
spring.redis.sentinel.nodes=192.168.1.241:26379,192.168.1.241:36379,192.168.1.241:46379
spring.redis.password=admin
## 关键地方 redisson
spring.redis.redisson.config=classpath:redisson.json
redisson.json
## redisson.json 文件
{
  "sentinelServersConfig":{
    "sentinelAddresses": ["redis://192.168.1.241:26379","redis://192.168.1.241:36379","redis://192.168.1.241:46379"],
    "masterName": "mymaster",
    "database": 0,
    "password":"admin"
  }
} 

  这样我们就建立了我们的Redisson的连接了,我们来看一下如何使用吧。

package com.redisclient.cluster;

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class RedisCluster {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private Redisson redisson;

    @GetMapping(value = "/getLock")
    public String getLock() {
        String lockKey = "lock";
        RLock redissonLock = redisson.getLock(lockKey);
        try {
            redissonLock.lock();
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
            if (stock > 0) {
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock", realStock + "");
                System.out.println("售卖成功,剩余" + realStock + "");

                return "success";
            } else {
                System.out.println("剩余库存不足");
                return "fail";
            }
        } finally {
            redissonLock.unlock();
        }
    }
}

  使用也是超级简单的,Redisson还有重入锁功能等等,有兴趣的可以去Redisson查看,地址:https://redisson.org/ 国外的地址打开可能会慢一些。Redis的分布式锁使用就差不多说到这里了,我们来回到我们刚才说到的Lua脚本这里。

Lua脚本和管道

Lua脚本

  lua脚本就是一个事务控制的过程,我们可以在lua脚本中写一些列的命令,一次性的塞入到我们的redis客户端,保证了原子性,要么都成功,要么都失败。好处在于减少与reidis的多次连接,可以替代redis的事务操作以及保证我们的原子性。

String luaString = "";//Lua脚本
jedis.eval(luaString, Arrays.asList("keysList"),Arrays.asList("valueList"));

  脚本我就不写了(我也不熟悉),我来解释一下eval的三个参数,第一个是我们的写好的脚本,然后我们的脚本可能传参数的,也就是我们KEYS[1]或者是ARGV[4],意思就是我们的KEYS[1]就是我们的ArrayList("keysList")中的第一项,ARGV[4]就是我们的ArrayList("valueList")的第四项。

管道

  管道和我们的和我们的Lua脚本差不多,不一样就是管道不会保证我们的事务,也就是说我们现在塞给管道10条命令 ,我们执行到第三条时报错了,后面的依然会执行,前面执行过的两条还是生效的。虽然可以减少我们的网络开销,也别一次塞太多命令进去,毕竟redis的是单线程的,不建议使用管道来操作redis,想深入了解的可以参照https://www.runoob.com/redis/redis-pipelining.html

  redis的分布式锁差不多就说这么多了,关键是实现思路,使用Redisson倒是很简单的,还有我们的Lua脚本和管道,Lua脚本可以保证事务,管道一次性可以执行多条命令,减少网络开销,但不建议使用,下次我们来说下,大厂用redis的一些使用注意事项和优化吧。

本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2019-10-28 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
相关产品与服务
云数据库 Redis
腾讯云数据库 Redis(TencentDB for Redis)是腾讯云打造的兼容 Redis 协议的缓存和存储服务。丰富的数据结构能帮助您完成不同类型的业务场景开发。支持主从热备,提供自动容灾切换、数据备份、故障迁移、实例监控、在线扩容、数据回档等全套的数据库服务。
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档