完成分布式锁的三种方式

最新推荐文章于 2024-11-03 08:30:37 发布
最新推荐文章于 2024-11-03 08:30:37 发布
阅读量71 收藏
点赞数
文章标签： lua java redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43383307/article/details/120009245
版权

第一种使用lua脚本完成分布式锁

package com.atguigu.bootredis01.controller;

import com.atguigu.bootredis01.util.RedisUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;

import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * @author 蒲成伟
 * @create 2021-08-30-13:49
 */

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

    private static final String REDIS_LOCK = "atguigu";

    @GetMapping("/buy_goods")
    public String buy_Goods() throws Exception {

        long start = System.currentTimeMillis();
        String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
        try {

            Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value, 10L, TimeUnit.SECONDS);
            if(!flag){
                System.out.println("枪锁失败");
                return "枪锁失败";
            }
            String result = stringRedisTemplate.opsForValue().get("goods:001");
            int goodsNumber = result==null ? 0:Integer.parseInt(result);
            if(goodsNumber > 0){
                int realNUmber = goodsNumber - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realNUmber));
                System.out.println("成功买到商品，还剩下："+realNUmber+"件库存"+"服务提供者是："+serverPort);
                return  Thread.currentThread().getName()+"来光顾"+"成功买到商品，还剩下："+realNUmber+"件库存"+"服务提供者是："+serverPort;
            }else {
                System.out.println(Thread.currentThread().getName()+"来光顾 "+"卖完了啊，下次早点来啊"+"服务提供者是："+serverPort);
            }
            return  "卖完了啊，下次早点来啊"+"服务提供者是："+serverPort;
        } finally {
            //不满足原子性，不能这么写
//            if( stringRedisTemplate.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
//                stringRedisTemplate.delete(REDIS_LOCK);
//            }
            //使用redis事务
//            while(true)
//            {
//                stringRedisTemplate.watch(REDIS_LOCK);
//                if(stringRedisTemplate.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
//                    stringRedisTemplate.setEnableTransactionSupport(true);
//                    stringRedisTemplate.multi();
//                    stringRedisTemplate.delete(REDIS_LOCK);
//                    List<Object> list = stringRedisTemplate.exec();
//                    if (list == null)
//                        continue;
//
//                }
//                stringRedisTemplate.unwatch();
//                break;
//
//            }
            //使用正常的写法
            Jedis jedis = RedisUtils.getJedis();
            String script ="if redis.call('get',KEYS[1]) == ARGV[1] " +
                    "then " +
                    "return redis.call('del',KEYS[1]) " +
                    "else " +
                    "    return 0 " +
                    "end";
            try {
                Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
                if("1".equalsIgnoreCase(eval.toString())){
                    System.out.println("-------del redis lock ok");
                }
                else {
                    System.out.println("-------del redis lock error");
                }
            }finally {
                if(null != jedis){
                    jedis.close();
                    long finish = System.currentTimeMillis();

                    long timeElapsed = finish - start;
                    System.out.println("耗费时间 " + timeElapsed);
                }
            }
        }


    }
}

第二种：使用redis事务完成分布式事务锁

package com.atguigu.bootredis01.controller;

import com.atguigu.bootredis01.util.RedisUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;

import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * @author 蒲成伟
 * @create 2021-08-30-13:49
 */

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

    private static final String REDIS_LOCK = "atguigu";

    @GetMapping("/buy_goods")
    public String buy_Goods() throws Exception {
        String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value, 10L, TimeUnit.SECONDS);
        if(!flag){
            System.out.println("枪锁失败");
            return "枪锁失败";
        }
        try {
            String result = stringRedisTemplate.opsForValue().get("goods:001");
            int goodsNumber = result==null ? 0:Integer.parseInt(result);
            if(goodsNumber > 0){
                int realNUmber = goodsNumber - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realNUmber));
                System.out.println("成功买到商品，还剩下："+realNUmber+"件库存"+"服务提供者是："+serverPort);
                return  Thread.currentThread().getName()+"来光顾"+"成功买到商品，还剩下："+realNUmber+"件库存"+"服务提供者是："+serverPort;
            }else {
                System.out.println(Thread.currentThread().getName()+"来光顾 "+"卖完了啊，下次早点来啊"+"服务提供者是："+serverPort);
            }
            return  "卖完了啊，下次早点来啊"+"服务提供者是："+serverPort;
        } finally {
            //不满足原子性，不能这么写
//            if( stringRedisTemplate.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
//                stringRedisTemplate.delete(REDIS_LOCK);
//            }
            //使用redis事务
//            while(true)
//            {
//                stringRedisTemplate.watch(REDIS_LOCK);
//                if(stringRedisTemplate.opsForValue().get(REDIS_LOCK).equalsIgnoreCase(value)){
//                    stringRedisTemplate.setEnableTransactionSupport(true);
//                    stringRedisTemplate.multi();
//                    stringRedisTemplate.delete(REDIS_LOCK);
//                    List<Object> list = stringRedisTemplate.exec();
//                    if (list == null)
//                        continue;
//
//                }
//                stringRedisTemplate.unwatch();
//                break;
//
//            }
            //使用正常的写法
            Jedis jedis = RedisUtils.getJedis();
            String script ="if redis.call('get',KEYS[1]) == ARGV[1] " +
                    "then " +
                    "return redis.call('del',KEYS[1]) " +
                    "else " +
                    "    return 0 " +
                    "end";
            try {
                Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
                if("1".equalsIgnoreCase(eval.toString())){
                    System.out.println("-------del redis lock ok");
                }
                else {
                    System.out.println("-------del redis lock error");
                }
            }finally {
                if(null != jedis){
                    jedis.close();
                }
            }
        }


    }
}

第三种：使用redisson加锁

    @Bean
    public Redisson getRedissonInstance(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379").setDatabase(0);
        return (Redisson) Redisson.create(config);
    }












package com.atguigu.bootredis01.controller;

import com.atguigu.bootredis01.util.RedisUtils;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import redis.clients.jedis.Jedis;

import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * @author 蒲成伟
 * @create 2021-08-30-13:49
 */

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

    private static final String REDIS_LOCK = "atguigu";

    @Autowired
    private Redisson redisson;

    @GetMapping("/buy_goods")
    public String buy_Goods() throws Exception {
        RLock redissonLock = redisson.getLock(REDIS_LOCK);
        redissonLock.lock();

        try {
            String result = stringRedisTemplate.opsForValue().get("goods:001");
            int goodsNumber = result==null ? 0:Integer.parseInt(result);
            if(goodsNumber > 0){
                int realNUmber = goodsNumber - 1;
                stringRedisTemplate.opsForValue().set("goods:001",String.valueOf(realNUmber));
                System.out.println("成功买到商品，还剩下："+realNUmber+"件库存"+"服务提供者是："+serverPort);
                return  Thread.currentThread().getName()+"来光顾"+"成功买到商品，还剩下："+realNUmber+"件库存"+"服务提供者是："+serverPort;
            }else {
                System.out.println(Thread.currentThread().getName()+"来光顾 "+"卖完了啊，下次早点来啊"+"服务提供者是："+serverPort);
            }
            return  "卖完了啊，下次早点来啊"+"服务提供者是："+serverPort;
        } finally {
            if (redissonLock.isLocked() && redissonLock.isHeldByCurrentThread())
            {
                redissonLock.unlock();
            }
        }


    }
}
CW_ZB666
关注
Redis：Redisson分布式锁的使用（推荐使用）
10JQKA的博客
11-17 2483
通过这个命令，对客户端1的加锁次数，累加1。第一段if判断语句，就是用“exists myLock”命令判断一下，如果你要加锁的那个锁key不存在的话，你就进行加锁。会成立，因为myLock的hash数据结构中包含的那个ID，就是客户端1的那个ID，也就是“8743c9c0-0795-4907-87fd-6c719a6b4586:1”接着第二个if判断，判断一下，myLock锁key的hash数据结构中，是否包含客户端2的ID，但是明显不是的，因为那里包含的是客户端1的ID。
三种实现分布式锁的方式
热门推荐
vincent
06-14 25万+
一、为什么要使用分布式锁我们在开发应用的时候，如果需要对某一个共享变量进行多线程同步访问的时候，可以使用我们学到的Java多线程的18般武艺进行处理，并且可以完美的运行，毫无Bug！注意这是单机应用，也就是所有的请求都会分配到当前服务器的JVM内部，然后映射为操作系统的线程进行处理！而这个共享变量只是在这个JVM内部的一块内存空间！后来业务发展，需要做集群，一个应用需要部署到几台机器上然后做负载均...
实现分布式锁的常用三种方式
2301_76166241的博客
07-11 2640
我们的系统都是分布式部署的，日常开发中，秒杀下单、抢购商品等等业务场景，为了防⽌库存超卖，都需要用到分布式锁。分布式锁其实就是，控制分布式系统不同进程共同访问共享资源的一种锁的实现。如果不同的系统或同一个系统的不同主机之间共享了某个临界资源，往往需要互斥来防止彼此干扰，以保证一致性。业界流行的分布式锁实现，一般有这3种方式：基于数据库实现的分布式锁基于Redis实现的分布式锁基于Zookeeper实现的分布式锁分布式锁：基于数据库实现主要有两种方式：1、悲观锁2、乐观锁A. 悲观锁（排他锁）
分布式锁3种实现方式
web15870125901的博客
09-28 1033
利用ThreadLocal实现，获取锁后将Redis中的value保存在ThreadLocal中，同一线程再次尝试获取锁的时候就先将 ThreadLocal 中的 值 与 Redis 的 value 比较，如果相同则表示这把锁所以该线程，即实现可重入锁。如果和自己的信息一样，那么自己直接获取到锁，如果不一样就再创建一个临时的顺序节点，参与排队，实现可重入。综上，采用Zookeeper作为分布式锁，你要么就获取不到锁，一旦获取到了，必定节点的数据是一致的，不会出现redis那种异步同步导致数据丢失的问题。
分布式锁的三种实现方式
liudachu的博客
06-08 950
上面几种方式，哪种方式都无法做到完美。就像CAP一样，在复杂性、可靠性、性能等方面无法同时满足，所以，根据不同的应用场景选择最适合自己的才是王道。1.从实现的复杂性角度（从高到低）zookeeper >= redis> 数据库数据库实现的分布式锁易于理解和实现，且不会给项目引入其他依赖。zookeeper和redis需要考虑的情况更多，实现相对较为复杂，但是都有现成的分布式锁框架curator和redision，用起来代码反而可能会更简洁。
分布式锁以及三种加锁方式
qq_39144436的博客
04-19 2949
在很多场景中，我们为了保证数据的最终一致性，需要很多的技术方案来支持，比如分布式事务、分布式锁等。那具体什么是分布式锁，分布式锁应用在哪些业务场景、如何来实现分布式锁呢？ 一 为什么要使用分布式锁 我们在开发应用的时候，如果需要对某一个共享变量进行多线程同步访问的时候，可以使用我们学到的锁进行处理，并且可以完美的运行，毫无Bug！ 注意这是单机应用，后来业务发展，需要做集群，一个应用需要部署到几台机器上然后做负载均衡，大致如下图： 上图可以看到，变量A存在三个服务器内存中（这个变量A主要体现是在一
【五斗米】实现分布式锁的三种方式
m0_64210833的博客
08-07 8966
在单击环境下，就是只有当前JVM虚拟机A中的多个线程对同一个Object（共享资源）进行操作，可以采用同步互斥（就是只有同一时间只有一个线程对共享资源进行事务操作）的方式，我们常用的方式就是采用加锁的方式解决，虽然不能保证数据的强一致性，但是能够保证数据的最终一致性。........................
分布式锁的三种实现方式 学习总结
weixin_44131922的博客
07-17 807
数据库分布式锁，redis 缓存分布式锁，zookeeper 分布式锁
Java三种方式实现redis分布式锁
了迹奇有没
04-28 2万+
一、引入原因 在分布式服务中，常常有如定时任务、库存更新这样的场景。 在定时任务中，如果不使用quartz这样的分布式定时工具，只是简单的使用定时器来进行定时任务，在服务分布式部署中，就有可能存在定时任务并发执行，造成一些问题。 在库存更新这样的场景中，我们服务对数据库同一条记录进行更新，并记录。对记录更新可以使用分布式锁，但对操作进行记录时，可能造成读未提交，造成记录错乱的情况。 在以上的场景中，我们引入了分布式事务锁。 二、分布式锁实现过程中的问题 问题一：异常导致锁没有释放 这个问题形成的原因就是程序
redis分布式锁的三种实现方式
Java_ttcd的博客
08-03 1540
超时之后锁被自动释放了，实例B获取到锁，并执行业务程序，执行完成之后把锁删除了。这个问题形成的原因就是程序在获取到锁之后，执行业务的过程中出现了异常，导致锁没有被释放。解决方案： 在释放锁之前判断一下，这把锁是不是自己的那一把，如果是别人的锁你就不要动。加锁时为value赋随机值，加锁的随机值等于解锁时的获取到的值，才能证明这把锁是你的。在定时任务中，如果不使用quartz这样的分布式定时工具，只是简单的使用定时器来进行定时任务，在服务分布式部署中，就有可能存在定时任务并发执行，造成一些问题。...
分布式锁三种实现方式及对比
12-14
本文将详细讨论三种常见的分布式锁实现方式：基于数据库、基于缓存（如Redis）以及基于Zookeeper，并对比它们的优缺点。 1. **基于数据库实现分布式锁** - **悲观锁**：使用`SELECT ... WHERE ... FOR UPDATE`...
Redis分布式锁的实现方式(redis面试题)
09-08
分布式锁是一种在分布式系统中实现锁的机制，用于协调分布在不同节点上的进程对共享资源的访问。在单机系统中，我们通常使用线程锁（如Java中的`synchronized`关键字或`java.util.concurrent.locks.Lock`接口）来...
分布式锁的三种实现方式.zip
08-26
在SpringBoot框架下，我们可以采用多种方式来实现分布式锁，这里主要介绍三种常见的实现方式：Zookeeper分布式锁、数据库锁和Redis分布式锁。 **Zookeeper分布式锁** Zookeeper是一个高性能的分布式服务框架，它...
Java分布式锁的三种实现方案
08-31
本文将详细介绍三种Java实现分布式锁的方案。 ### 方案一：数据库乐观锁 乐观锁是一种假设大多数情况下不会发生并发冲突的锁机制。它在读取数据时不会加锁，只有在更新数据时才会检查在此期间是否有其他事务对数据...
《Redis实战》note-11 使用Lua脚本提升性能
qq_42783188的博客
10-31 509
1. Lua脚本载入的参数； 2. Lua脚本返回值的转换； 3. Lua脚本是原子操作； 4. Lua脚本可以提升锁性能的原理； 5. Lua脚本替代事务的原因； 6. 分片列表的构成； 7. 分片列表的推入、弹出操作；
【LuatOS】Lua与LuatOS中的Math.randomseed
u010160146的博客
10-31 886
在本地Lua环境、在线Lua环境、本地LuatOS环境、在线LuatOS环境4个Lua运行环境中，执行两次“实验代码”以测试`math.randomseed()`的表现。实验结果表明，在本地LuatOS环境中`math.randomseed()`不能够重置`math.random()`的随机数生成序列，本地Lua环境、在线Lua环境、在线LuatOS环境3个环境中，`math.randomseed()`均能够重置`math.random()`的随机数生成序列。
Lua 函数
wjs2024的博客
10-26 578
在 Lua 中，函数通过function关键字定义。函数可以有一个或多个参数，以及一个返回值。end这个函数名为add，它接受两个参数a和b，并返回它们的和。
redis源码系列--（二）--multi/exec/eval命令执行流程
最新发布
cser的博客
11-03 353
redis源码系列第三篇---multi/exec/eval命令执行流程
优雅的LUA数据记录方法-serpent序列化+LUA Table
qq_42039294的博客
11-01 676
文章记录了如何使用serpent将Lua Table序列化到文件中，再反序列化到运行中的table。
Redis与Zookeeper分布式锁实现详解
本文首先提及了Redis作为分布式锁的实现方式。Redis分布式锁的实现原理基于`setnx`命令（设置并返回结果，如果键不存在）和`expire`命令（设置键的过期时间）。通过这两个命令，可以确保在同一时刻只有一个客户端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值