首页 / REDIS / redis实现分布式锁--工具类

redis实现分布式锁--工具类

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了redis实现分布式锁--工具类，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5613字，纯文字阅读大概需要9分钟。

内容图文

1.引入依赖

            <
            dependency
            >
            <
            groupId
            >org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><version>2.0.5.RELEASE</version></dependency><dependency><groupId>org.redisson</groupId><artifactId>redisson</artifactId><version>3.10.7</version></dependency>

2.配置文件：application.properties

            spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=123456

3.配置类：RedissonConfig

            package
             com.baidu.config;


            import
             org.redisson.Redisson;

            import
             org.redisson.api.RedissonClient;

            import
             org.redisson.config.Config;

            import
             org.springframework.beans.factory.annotation.Value;

            import
             org.springframework.context.annotation.Bean;

            import
             org.springframework.context.annotation.Configuration;

@Configuration

            public
            class
             RedissonConfig {

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

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

4.redis工具类：RedisUtils

            package
             com.baidu.utils;


            import
             org.redisson.RedissonMultiLock;

            import
             org.redisson.RedissonRedLock;

            import
             org.redisson.api.RLock;

            import
             org.redisson.api.RedissonClient;


            import
             java.util.concurrent.ExecutionException;

            import
             java.util.concurrent.Future;

            import
             java.util.concurrent.TimeUnit;


            public
            class
             RedisUtils {

    
            /**
            
     * redis可重入锁
     * Redisson的分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口，同时还支持自动过期解锁。
     * 
            @param
             redisson
     
            */
            public
            void
             testReentrantLock(RedissonClient redisson){

        RLock lock = redisson.getLock("anyLock");
        try{
            // 1. 最常见的使用方法
            //lock.lock();

            // 2. 支持过期解锁功能,10秒钟以后自动解锁, 无需调用unlock方法手动解锁
            //lock.lock(10, TimeUnit.SECONDS);

            // 3. 尝试加锁，最多等待3秒，上锁以后10秒自动解锁boolean res = lock.tryLock(3, 10, TimeUnit.SECONDS);
            if(res){    //成功
                // do your business            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    /**
     * Redisson同时还为分布式锁提供了异步执行的相关方法：
     * @param redisson
     */publicvoid testAsyncReentrantLock(RedissonClient redisson){
        RLock lock = redisson.getLock("anyLock");
        try{
            lock.lockAsync();
            lock.lockAsync(10, TimeUnit.SECONDS);
            Future<Boolean> res = lock.tryLockAsync(3, 10, TimeUnit.SECONDS);

            if(res.get()){
                // do your business
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    /**
     * 公平锁（Fair Lock）
     * Redisson分布式可重入公平锁也是实现了java.util.concurrent.locks.Lock接口的一种RLock对象。在提供了自动过期解锁功能的同时，保证了当多个Redisson客户端线程同时请求加锁时，优先分配给先发出请求的线程
     *
     * @param redisson
     */publicvoid testFairLock(RedissonClient redisson){

        RLock fairLock = redisson.getFairLock("anyLock");
        try{
            // 最常见的使用方法            fairLock.lock();

            // 支持过期解锁功能, 10秒钟以后自动解锁,无需调用unlock方法手动解锁
            fairLock.lock(10, TimeUnit.SECONDS);

            // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            fairLock.unlock();
        }
    }

    /**
     * Redisson同时还为分布式可重入公平锁提供了异步执行的相关方法：
     * @param redisson
     */publicvoid testFairLockAsynchronous(RedissonClient redisson){

        RLock fairLock = redisson.getFairLock("anyLock");
        try{
            // 最常见的使用方法            fairLock.lockAsync();

            // 支持过期解锁功能, 10秒钟以后自动解锁,无需调用unlock方法手动解锁
            fairLock.lockAsync(10, TimeUnit.SECONDS);

            // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
            Future<Boolean> res = fairLock.tryLockAsync(100, 10, TimeUnit.SECONDS);
        } finally {
            fairLock.unlock();
        }
    }

    /**
     * 联锁（MultiLock）
     * Redisson的RedissonMultiLock对象可以将多个RLock对象关联为一个联锁，每个RLock对象实例可以来自于不同的Redisson实例。
     * @param redisson1
     * @param redisson2
     * @param redisson3
     */publicvoid testMultiLock(RedissonClient redisson1,
                              RedissonClient redisson2, RedissonClient redisson3){

        RLock lock1 = redisson1.getLock("lock1");
        RLock lock2 = redisson2.getLock("lock2");
        RLock lock3 = redisson3.getLock("lock3");

        RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);

        try {
            // 同时加锁：lock1 lock2 lock3, 所有的锁都上锁成功才算成功。            lock.lock();

            // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 红锁（RedLock）
     *
     * Redisson的RedissonRedLock对象实现了Redlock介绍的加锁算法。该对象也可以用来将多个RLock
     * 对象关联为一个红锁，每个RLock对象实例可以来自于不同的Redisson实例
     * @param redisson1
     * @param redisson2
     * @param redisson3
     */publicvoid testRedLock(RedissonClient redisson1,
                            RedissonClient redisson2, RedissonClient redisson3){

        RLock lock1 = redisson1.getLock("lock1");
        RLock lock2 = redisson2.getLock("lock2");
        RLock lock3 = redisson3.getLock("lock3");

        RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);

        try {
            // 同时加锁：lock1 lock2 lock3, 红锁在大部分节点上加锁成功就算成功。            lock.lock();

            // 尝试加锁，最多等待100秒，上锁以后10秒自动解锁boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 另外还有几种锁：
     *
     * 读写锁（ReadWriteLock）
     * Redisson的分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。同时还支持自动过期解锁。该对象允许同时有多个读取锁，但是最多只能有一个写入锁。
     *
     * 信号量（Semaphore）
     * Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。
     *
     * 可过期性信号量（PermitExpirableSemaphore）
     * Redisson的可过期性信号量（PermitExpirableSemaphore）实在RSemaphore对象的基础上，为每个信号增加了一个过期时间。每个信号可以通过独立的ID来辨识，释放时只能通过提交这个ID才能释放。
     *
     * 闭锁（CountDownLatch）
     * Redisson的分布式闭锁（CountDownLatch）Java对象RCountDownLatch采用了与java.util.concurrent.CountDownLatch相似的接口和用法。
     *
     */
}

参考资料：
1. https://www.jianshu.com/p/3d1effcf47ba
2. https://crazyfzw.github.io/2019/04/15/distributed-locks-with-redis/

原文：https://www.cnblogs.com/htq29study/p/12003742.html

内容总结

以上是互联网集市为您收集整理的redis实现分布式锁--工具类全部内容，希望文章能够帮你解决redis实现分布式锁--工具类所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1165383.html

来源：【匿名】

【上一篇】redis集群调试1 【下一篇】redis可以做什么？

更多 ►

【redis实现分布式锁--工具类】教程文章相关的互联网学习教程文章

分布式系统--封装Redis分布式锁解决跨进程并发秒杀引起的超卖问题【代码】【图】

一、单进程多线程的锁--线程锁锁住线程的锁叫线程锁，像C#中的lock，Monitor，让线程排队，同一时刻只能有一个线程进来，让线程同步排队。二、多进程的锁--分布式锁锁住进程的锁就叫分布式锁，是锁住进程的一种机制，让进程排队。三、电商秒杀场景1、单体架构并发量不够，秒杀服务只能并发1000，而客户端同时发送3000个请求。2、集群架构这时候就需要多两个角色，一个角色是网关，一个角色是秒杀集群，网关把用户请求转发到3个秒...

redis分布式锁-lua脚本【代码】

package com.tuling.jedis;import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig;import java.io.IOException; import java.util.Arrays;/*** 访问redis单机** @author*/publicclass JedisSingleTest {publicstaticvoid main(String[] args) throws IOException {JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();jedisPoolConfig.setMaxTotal(20);jedi...

为什么我们做分布式使用 Redis ？（转）【图】

绝大部分写业务的程序员，在实际开发中使用 Redis 的时候，只会 Set Value 和 Get Value 两个操作，对 Redis 整体缺乏一个认知。这里对 Redis 常见问题做一个总结，解决大家的知识盲点。1、为什么使用 Redis　　在项目中使用 Redis，主要考虑两个角度：性能和并发。如果只是为了分布式锁这些其他功能，还有其他中间件 Zookpeer 等代替，并非一定要使用 Redis。性能：　　如下图所示，我们在碰到需要执行耗时特别久，且结果不频繁变...

借助共享缓存redis实现分布式互斥锁【代码】

新开发的系统需要控制每个时刻回收缓存的GC线程有且只有一个在运行，如果有多个线程同时运行，会造成系统崩溃。如果只有一个JVM进程那么很好办，简单的借助synchronized关键字就行了。可是我的系统要部署在多台服务器，每台服务器上部署多个实例上。而synchronized仅仅在单进程里有用。考虑借助共享数据源redis实现功能。 redis提供一个方法，SETNX key value。将 key 的值设为 value ，当且仅当 key 不存在。若给定的 key ...

Scrapy-redis分布式+Scrapy-redis实战【代码】【图】

【学习目标】Scrapy-redis分布式的运行流程Scheduler与Scrapy自带的Scheduler有什么区别Duplication Filter作用源码自带三种spider的使用6. Scrapy-redis分布式组件Scrapy 和 scrapy-redis的区别Scrapy 是一个通用的爬虫框架，但是不支持分布式，Scrapy-redis是为了更方便地实现Scrapy分布式爬取，而提供了一些以redis为基础的组件(仅有组件)。pip install scrapy-redisScrapy-redis提供了下面四种组件（components）：(四种组件意...

redisLock redis分布式锁【代码】

redis setnx cmmandjava object condition queue 条件队列retrycount 带有重试次数限制object wait time 带有超时时间的waitdelete lock 删除远程锁acquire lock 申请lockrelease lock 释放lockdemo 演示锁的粒度问题，锁分解、锁分段github https://github.com/Plen-wang/redis-lockredis setnx 命令特性当指定key不存在时才设置。也就是说，如果返回1说明你的命令被执行成功了，redis服务器中的key是你之前设置的值。如果返回0，...

spring data redis分布式锁【代码】

问题项目采用spring-boot-starter-data-redis，RedisTemplate中没有同时设置NX和EX的方法，如果使用setIfAbsent()方法也就是NX，再设置过期时间expire()也就是EX,如果在设置EX时失败则会造成死锁。在jedis中提供了同时设置NX和EX的方法，这里通过RedisTemplate的execute()方法获取Jedis。存在问题解决方案可以可以参考Redisson哨兵模式下有问题，Master挂了可能没有复制到Slave导致锁丢失如果是多个系统redis配置的库不同会有问题因...

如何实现redis分布式缓存

摘要: 第一：Redis 是什么？ Redis是基于内存、可持久化的日志型、Key-Value数据库高性能存储系统，并提供多种语言的API. 第二：出现背景数据结构(Data Structure)需求越来越多, 但memcache中没有, 影响开发效率性能需求, 随着读操作的量的上升需要解决，经历的过程有: 数据库读写分离(M/S)–>数据库使用多个Slave–>增加Cache (memcache)–>转到Redis 解决写的问题：水平拆分，对表的拆分，将有的用户放在这个表，有的用户放...

SpringBoot学习示例—整合Redis之StringRedisTemplate及实现redis乐观锁，分布式锁、事务【代码】【图】

1. 前言2. 整合Redis快速入门3. StringRedisTemplate基本操作及测试4. 实现Redis事务5. Redis乐观锁(分布式锁）1. 前言这篇文章你能学到，SpringBoot整合Redis的最简单方式，不需要任何复杂的配置。还有完整的乐观锁，分布式锁，事务等实现样例代码供你选择。2. 整合Redis快速入门SpringBoot项目引入redis依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-d...

scrapy-redis 分布式爬虫爬取房天下网站所有国内城市的新房和二手房信息【代码】

scrapy-redis 分布式爬虫爬取房天下网站所有国内城市的新房和二手房信息先完成单机版的爬虫，然后将单机版爬虫转为分布式爬虫爬取思路1. 进入 https://www.fang.com/SoufunFamily.htm 页面，解析所有的省份和城市，获取到城市首页链接 2. 通过分析，每个城市的新房都是在首页链接上添加newhouse和house/s/字符串，二手房都死在首页链接上添加esf字段以上海为例：首页：https://sh.fang.com/ 新房：https://sh.newhouse....

一站式学习Redis 从入门到高可用分布式实践（慕课）第五章 Redis持久化的取舍和选择【图】

Redis持久化的取舍和选择持久化的作用 RDB AOF RDB和AOF的决择原文：https://www.cnblogs.com/jiang910/p/10025879.html

使用redis分布式锁解决并发线程资源共享问题【代码】【图】

众所周知, 在多线程中，因为共享全局变量,会导致资源修改结果不一致，所以需要加锁来解决这个问题，保证同一时间只有一个线程对资源进行操作但是在分布式架构中，我们的服务可能会有n个实例，但线程锁只对同一个实例有效，就需要用到分布式锁----redis setnx 原理：　　修改某个资源时, 在redis中设置一个key，value根据实际情况自行决定如何表示　　我们既然要通过检查key是否存在（存在表示有线程在修改资源，资源上锁，其他线程...

Redis 分布式锁【代码】

1 #include <stdio.h>2 #include <stdlib.h>3 #include <string.h>4// -------------------- 5 #include <unistd.h>6 #include <pthread.h>7// -------------------- 8 #include <hiredis.h>9// -------------------- 10 #include "thread_helper.h" 11 12#define ATOMIC_UNLOCK 013#define ATOMIC_LOCK 114 15intlock = 0;16int num = 0;17int total_num = 50;18 ThreadSchema* ts;19 20bool acquire_lock(int sn, redisContext...