分布式专题——分布式锁全套代码实现（zk，redisson，redis等）

最新推荐文章于 2024-02-16 21:22:46 发布
最新推荐文章于 2024-02-16 21:22:46 发布
阅读量2k 收藏 7
点赞数 2
分类专栏： 架构师-分布式框架 文章标签： redis 分布式 lua
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouhengzhe/article/details/122228046
版权

文章目录

1、乐观锁，悲观锁

乐观锁：版本号，也就是version字段；时间戳 AtomicInteger相关类
悲观锁：for update 对标单体的Synchronized，ReentrantLock

2、Redis分布式锁（setnx+lua）自动释放锁

pom

 <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
		<version>2.1.7.RELEASE</version>        
</dependency>

application.properties

spring.redis.host=localhost
spring.redis.password=123456

工具类

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.data.redis.core.types.Expiration;

import java.util.Arrays;
import java.util.List;
import java.util.UUID;

@Slf4j
public class RedisLock implements AutoCloseable {

    private RedisTemplate redisTemplate;
    private String key;
    private String value;
    //单位：秒
    private int expireTime;

    public RedisLock(RedisTemplate redisTemplate,String key,int expireTime){
        this.redisTemplate = redisTemplate;
        this.key = key;
        this.expireTime=expireTime;
        this.value = UUID.randomUUID().toString();
    }

    /**
     * 获取分布式锁
     * @return
     */
    public boolean getLock(){
        RedisCallback<Boolean> redisCallback = connection -> {
            //设置NX
            RedisStringCommands.SetOption setOption = RedisStringCommands.SetOption.ifAbsent();
            //设置过期时间
            Expiration expiration = Expiration.seconds(expireTime);
            //序列化key
            byte[] redisKey = redisTemplate.getKeySerializer().serialize(key);
            //序列化value
            byte[] redisValue = redisTemplate.getValueSerializer().serialize(value);
            //执行setnx操作
            Boolean result = connection.set(redisKey, redisValue, expiration, setOption);
            return result;
        };

        //获取分布式锁
        Boolean lock = (Boolean)redisTemplate.execute(redisCallback);
        return lock;
    }

    public boolean unLock() {
        String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then\n" +
                "    return redis.call(\"del\",KEYS[1])\n" +
                "else\n" +
                "    return 0\n" +
                "end";
        RedisScript<Boolean> redisScript = RedisScript.of(script,Boolean.class);
        List<String> keys = Arrays.asList(key);

        Boolean result = (Boolean)redisTemplate.execute(redisScript, keys, value);
        log.info("释放锁的结果："+result);
        return result;
    }


    @Override
    public void close() throws Exception {
        unLock();
    }
}

加锁

@Autowired
    private RedisTemplate redisTemplate;

    @RequestMapping("redisLock")
    public String redisLock(){
        log.info("我进入了方法！");
        try (RedisLock redisLock = new RedisLock(redisTemplate,"redisKey",30)){
            if (redisLock.getLock()) {
                log.info("我进入了锁！！");
                Thread.sleep(15000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        log.info("方法执行完成");
        return "方法执行完成";
    }

3、Zookeeper实现分布式锁

pom

<dependency>
		<groupId>org.apache.zookeeper</groupId>
		<artifactId>zookeeper</artifactId>
		<version>3.4.14</version>
<dependency>

工具类（自动释放锁）

import lombok.extern.slf4j.Slf4j;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.Collections;
import java.util.List;

@Slf4j
public class ZkLock implements AutoCloseable, Watcher {

    private ZooKeeper zooKeeper;
    private String znode;

    public ZkLock() throws IOException {
        this.zooKeeper = new ZooKeeper("localhost:2181",
                10000,this);
    }

    public boolean getLock(String businessCode) {
        try {
            //创建业务 根节点
            Stat stat = zooKeeper.exists("/" + businessCode, false);
            if (stat==null){
                zooKeeper.create("/" + businessCode,businessCode.getBytes(),
                        ZooDefs.Ids.OPEN_ACL_UNSAFE,
                        CreateMode.PERSISTENT);
            }

            //创建瞬时有序节点  /order/order_00000001
            znode = zooKeeper.create("/" + businessCode + "/" + businessCode + "_", businessCode.getBytes(),
                    ZooDefs.Ids.OPEN_ACL_UNSAFE,
                    CreateMode.EPHEMERAL_SEQUENTIAL);

            //获取业务节点下 所有的子节点
            List<String> childrenNodes = zooKeeper.getChildren("/" + businessCode, false);
            //子节点排序
            Collections.sort(childrenNodes);
            //获取序号最小的（第一个）子节点
            String firstNode = childrenNodes.get(0);
            //如果创建的节点是第一个子节点，则获得锁
            if (znode.endsWith(firstNode)){
                return true;
            }
            //不是第一个子节点，则监听前一个节点
            String lastNode = firstNode;
            for (String node:childrenNodes){
                if (znode.endsWith(node)){
                    zooKeeper.exists("/"+businessCode+"/"+lastNode,true);
                    break;
                }else {
                    lastNode = node;
                }
            }
            synchronized (this){
                wait();
            }

            return true;

        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
    
    @Override
    public void close() throws Exception {
        zooKeeper.delete(znode,-1);
        zooKeeper.close();
        log.info("我已经释放了锁！");
    }

    @Override
    public void process(WatchedEvent event) {
        if (event.getType() == Event.EventType.NodeDeleted){
            synchronized (this){
                notify();
            }
        }
    }
}

代码实现：

 @RequestMapping("zkLock")
    public String zookeeperLock(){
        log.info("我进入了方法！");
        try (ZkLock zkLock = new ZkLock()) {
            if (zkLock.getLock("order")){
                log.info("我获得了锁");
                Thread.sleep(10000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        log.info("方法执行完成！");
        return "方法执行完成！";
    }

4、Zookeeper的Curator实现分布式锁

pom

<dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.14</version>
    </dependency>
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-recipes</artifactId>
        <version>4.2.0</version>
    </dependency>

实例化对象

 @Bean(initMethod="start",destroyMethod = "close")
    public CuratorFramework getCuratorFramework() {
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        CuratorFramework client = CuratorFrameworkFactory.newClient("localhost:2181", retryPolicy);
        return client;
    }

代码实现

  @Autowired
    private CuratorFramework client;

    @RequestMapping("curatorLock")
    public String curatorLock(){
        log.info("我进入了方法！");
        InterProcessMutex lock = new InterProcessMutex(client, "/order");
        try{
            if (lock.acquire(30, TimeUnit.SECONDS)){
                log.info("我获得了锁！！");
                Thread.sleep(10000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                log.info("我释放了锁！！");
                lock.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        log.info("方法执行完成！");
        return "方法执行完成！";
    }

5、Spring集成Redisson原生

pom

<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.16.7</version>
</dependency>

配置类

@Bean
    public RedissonClient redissonClient(){
        Config config=new Config();
        config.useSingleServer().setAddress("redis://192.168.73.130:6379");
        return Redisson.create(config);
    }

使用


//引用
@Autowired 
private RedissonClient redisson;

//代码中使用
		RLock rLock = redisson.getLock("order");
        try {
            rLock.lock(30, TimeUnit.SECONDS);
            log.info("我获得了锁！！！");
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            log.info("我释放了锁！！");
            rLock.unlock();
        }

6、SpringBoot集成Redisson

pom

<dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.13.6</version>
    </dependency>

添加：redisson.xml文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:redisson="http://redisson.org/schema/redisson"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://redisson.org/schema/redisson
       http://redisson.org/schema/redisson/redisson.xsd
">

    <redisson:client>
        <redisson:single-server address="redis://localhost:6379"/>
    </redisson:client>
</beans>

启动类中添加

@ImportResource("classpath:redisson.xml")*

代码中使用

@Autowired
    private RedissonClient redisson;

    @RequestMapping("redissonLock")
    public String redissonLock() {
        RLock rLock = redisson.getLock("order");
        log.info("我进入了方法！！");
        try {
            rLock.lock(30, TimeUnit.SECONDS);
            log.info("我获得了锁！！！");
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            log.info("我释放了锁！！");
            rLock.unlock();
        }
        log.info("方法执行完成！！");
        return "方法执行完成！！";
    }

下面是本人的公众号：（有兴趣可以扫一下，文章会同步过去）
在这里插入图片描述

我是小白弟弟，一个在互联网行业的小白，立志成为一名架构师
https://blog.csdn.net/zhouhengzhe?t=1

zhz小白
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
redis分布式锁与zk分布式锁的对比
qq_27877781的博客
03-12 4040
·
浅析Redis分布式锁——从自己实现到Redisson的实现
Linuxhus的博客
12-19 7949
当我们在单机情况下，遇到并发问题，可以使用juc包下的lock锁，或者synchronized关键字来加锁。但是这俩都是JVM级别的锁，如果跨了JVM这两个锁就不能控制并发问题了，也就是说在分布式集群环境中，需要寻求其他方法来解决并发问题。前面也说到可以使用redis的setnx操作，如果不存在则set，如果存在则不set。也就是说每个服务实例都对同一个key进行操作。谁能set成功就认为获取到了锁。可以执行下面的操作。执行完之后释放锁。如下按照上述逻辑来简单实现一个分布式锁： package com.
三、详解Redis分布式锁&Redisson分布式锁
2301_77203215的博客
01-23 1316
在传统的java进程中，我们常常用Synchronized或者ReentrantLock来对临界区进行加锁,防止多个线程之间并行访问,导致数据读写异常。但是这种锁的粒度仅限于当前jvm中，在工业生产环境下，往往一个web项目会部署多台机器，也就意味着会有多个jvm。那么这几个jvm是独立的，这就导致上述的锁失效。分布式锁是一种在分布式系统环境下，通过多个节点对共享资源进行访问控制的机制。
redis分布式锁&redisson
pscool的博客
02-16 1906
利用set nx ex获取锁，并设置过期时间，保存线程标示释放锁时先判断线程标示是否与自己一致，一致则删除锁利用set nx满足互斥性利用set ex保证故障时锁依然能释放，避免死锁，提高安全性利用Redis集群保证高可用和高并发特性Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务，其中就包含了各种分布式锁的实现。
分布式锁、ZK分布式锁、Redis分布式锁
weixin_35794878的博客
01-22 909
深入刨析zookeeper分布式锁，redis分布式锁的实现原理。两者之间的对比。
zk和redis分布式锁比较
本作者：想花
12-06 2021
一、zookeeper简介 统一管理分布式集群，ZooKeeper 是一个集中式服务，用于维护配置信息、命名、提供分布式同步和提供组服务。分布式应用程序以某种形式使用所有这些类型的服务。每次实现它们时，都需要进行大量工作来修复不可避免的错误和竞争条件。由于实现这些服务的难度，应用程序最初通常会吝啬它们，这使得它们在发生变化时变得脆弱且难以管理。即使正确完成，这些服务的不同实现也会导致部署应用程序时的管理复杂性。 主要是监听各个节点的情况，ZooKeeper 是分布式应用的高性能协调服务。它在一个简单的界面中
Redis实现分布式锁
07-27 3万+
分布式锁及实现方案
redis和zk实现分布式锁的优缺点
大道至简
07-07 2094
redis和zk实现分布式锁的优缺点
Redis的分布式锁详解
热门推荐
张维鹏的博客
01-25 9万+
1、什么是分布式锁： 为了防止分布式系统中的多个进程之间相互干扰，我们需要一种分布式协调技术来对这些进程进行调度。而这个分布式协调技术的核心就是来实现这个分布式锁。 2、分布式锁应该具备哪些条件 在分布式系统环境下，一个方法在同一时间只能被一个机器的一个线程执行 高可用的获取锁与释放锁 高性能的获取锁与释放锁 具备可重入特性（可理解为重新进入，由多于一个任务并发使用，而不必担心数据错误） 具备锁失效机制，防止死锁 具备非阻塞锁特性，即没有获取到锁将直接返回获取锁失败 分布式锁的实.
redis和zookeeper实现分布式锁的区别
01-20
3. **操作难度**：Redis实现分布式锁较为复杂，需要处理时间计算、锁续期等问题；而Zookeeper通过创建和监听临时节点，实现逻辑更为清晰简单。 总结来说，Redis和Zookeeper在实现分布式锁时各有优缺点。Redis适合对...
分布式锁的感悟（redis，redisson，zk）
最新发布
06-24
分布式锁的感悟（redis，redisson，zk）
zk:redis分布式锁.zip
10-23
本压缩包“zk:redis分布式锁.zip”提供了基于Zookeeper（zk）和Redis两种分布式锁实现的示例和相关资料。 首先，我们来看Zookeeper（zk）的分布式锁。Zookeeper是Apache的一个开源项目，提供了一个高可用的、高性能...
基于redis实现分布式锁的原理与方法
12-14
zk实现分布式锁 今天我们介绍通过redis实现分布式锁。实际上这三种和java对比看属于一类。都是属于程序外部锁。 原理剖析 上述三种分布式锁都是通过各自为依据对各个请求进行上锁，解锁从而控制放行还是拒绝。...
java面试题Redis分布式锁+zk 分布式锁.md
09-15
java面试题Redis分布式锁+zk 分布式锁.md
详解Redis核心数据结构和高性能原理分析（一）
zhouhengzhe的博客
12-27 6217
1、Redis是单线程吗？ Redis 的单线程主要是指 Redis 的网络 IO 和键值对读写是由一个线程来完成的，这也是 Redis 对外提供键值存储服务的主要流程。但 Redis 的其他功能，比如持久化、异步删除、集群数据同步等，其实是由额外的线程执行的。 2、Redis 单线程为什么还能这么快？ 它所有的数据都在内存中，所有的运算都是内存级别的运算，而且单线程避免了多线程的切换性能损耗问题。 因为 Redis 是单线程，所以要小心使用 Redis 指令，对于那些耗时的指令(比如 keys)，
Redis使用总结（万字长篇）
zhouhengzhe的博客
07-19 3133
文章目录1、Redis入门1.1测试性能1.2、基础知识1.3、redis为什么是单线程但是那么快呢？2、五大基本数据类型2.1、redis-key2.2、String（字符串）2.3、List2.4、Set（集合）2.5、Hash2.6、Zset 1、Redis入门 在线数据库（可以玩的）：https://try.redis.io/ Redis什么？ Redis 是一种开源（BSD 许可）、内存中数据结构存储，用作数据库、缓存和消息代理。Redis 提供了诸如字符串、散列、列表、集合、带范围查询的排序集
面试专题——Redis
zhouhengzhe的博客
01-27 2741
文章目录一、Redis总结1、Redis数据结构1.1、Redis 基本特性1.2、Redis应用场景1.3、Redis有哪几种数据结构，原理，应用场景？1.3.1、String1.3.1.1、原理1.3.1.2、常用API1.3.1.3、应用场景1.3.2、List1.3.2.1、原理：1.3.2.2、常用API1.3.2.3、应用场景1.2、zset用过吗，底层数据结构是什么？1.3、为什么使用跳表？跟B+树怎么比？查找的时间复杂度是多少？1.4、GEO是干嘛的？举个场景？1.5、HyperLogLog
ShardingSphere入门到实践
zhouhengzhe的博客
09-08 2442
1、MySQL搭建主从集群 1.1、好处 数据安全 给主服务增加一个数据备份。基于这个目的，可以搭建主从架构，或者也可以基于主从架构搭建互主的架构。 读写分离 MySQl的主从架构是读写分离的一个基础。 读写分离需要第三方中间件，比如ShardingSphere，MyCat。。。 适用于读多写少，读请求远远高于写请求 当主服务的访问压力过大时，可以将数据读请求转为由从服务来分担，主服务只负责数据写入的请求，这样大大缓解数据库的访问压力。 3、故障转移-高可用 当MySQL主服务宕机后，可以由
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhz小白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值