脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 数据库 → Redis → redis哨兵模式分布式锁实现与实践

redis哨兵模式分布式锁实现与实践方式(redisson)

 更新时间：2024年03月05日 14:38:32   作者：喵喵@香菜  
这篇文章主要介绍了redis哨兵模式分布式锁实现与实践方式(redisson),具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教

一、前言

在某个线程操作数据库中的某条数据时，我们需要确保当前时刻只有一个线程在操作这条记录，如果有两个线程竞争同一个数据，就需要在考虑先后执行顺序以后，那么怎样在一个线程拿到这条数据时，阻塞其他线程操作呢？

分布式锁就可以解决上述难题。

以下演示是利用分布式锁，确保同一时间只有一个线程在操作数据库，阻塞其他线程。

环境：

  • redis（哨兵模式）
  • spring boot

二、redis的配置（注意是哨兵模式）

1）依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zlc</groupId>
    <artifactId>distributedlock-a</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>distributedlock-a</name>
    <description>分布式锁（哨兵模式）</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.3.2</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2）redis配置

server:
  port: 8081
spring:
  redis:
    sentinel:
      master: testmaster
      nodes: 127.0.0.1:26379,127.0.0.1:36379,127.0.0.1:16379
    timeout: 3000          # 超时时间(数据处理超时时间，不是连接超时时间)
    lettuce:
      pool:
        max-active: 200     #连接池最大连接数（使用负值表示没有限制）
        max-idle: 20        #连接池中的最大空闲连接
        min-idle: 5         #连接池中的最小空闲连接
        max-wait: -1        #连接池最大阻塞等待时间（使用负值表示没有限制）
    password: 123456        #redis 密码
    database: 1             # 使用的是库1，如果不配置，则使用默认的0

三、代码实战

根据上面的配置文件，将redis的各个配置转换为实体对象

1）sentinel 节点

package com.zlc.distributedlocka.model.redis;

import lombok.Data;
import lombok.ToString;

/**
 * @author : 追到乌云的尽头找太阳-（Jacob）
 * @date : 2020/1/20 11:13
 **/
@Data
@ToString
public class RedisSentinelModel {
    
    private String master;

    private String nodes;
}

2）pool节点

package com.zlc.distributedlocka.model.redis;

import lombok.Data;
import lombok.ToString;

/**
 * @author : 追到乌云的尽头找太阳-（Jacob）
 * @date : 2020/1/20 11:16
 **/
@Data
@ToString
public class RedisPoolModel {

    private int maxIdle;

    private int minIdle;

    private int maxActive;

    private int maxWait;
    
}

3）Lettuce 节点

package com.zlc.distributedlocka.model.redis;

import lombok.Data;

/**
 * @author : 追到乌云的尽头找太阳-（Jacob）
 * @date : 2020/1/20 11:18
 **/
@Data
public class RedisLettuceConfig {
    
    private RedisPoolModel redisPoolModel;
    
}

4）redis

package com.zlc.distributedlocka.model.redis;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * @author : 追到乌云的尽头找太阳-（Jacob）
 * @date : 2020/1/20 11:21
 **/
@Data
@Configuration
@ConfigurationProperties(prefix = "spring.redis")
public class RedisModel {

    private int database;
    /**
     * 等待节点回复命令的时间。该时间从命令发送成功时开始计时
     **/
    private int timeout;

    private String password;

    /**
     * 池配置
     */
    private RedisLettuceModel lettuce;

    /**
     * 哨兵配置
     */
    private RedisSentinelModel sentinel;
}

5）redisson

package com.zlc.distributedlocka.config;

import com.zlc.distributedlocka.model.redis.RedisModel;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.ReadMode;
import org.redisson.config.SentinelServersConfig;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.apache.commons.lang3.StringUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author : 追到乌云的尽头找太阳-（Jacob）
 * @date : 2020/1/20 11:27
 **/
@Configuration
@EnableConfigurationProperties(RedisModel.class)
public class RedissonConfig {

    private final RedisModel redisModel;
    
    public RedissonConfig(RedisModel redisModel) {
        this.redisModel = redisModel;
    }

    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        String [] nodes = redisModel.getSentinel().getNodes().split(",");
        List<String> newNodes = new ArrayList<>(nodes.length);
        newNodes.addAll(Arrays.asList(nodes));

        SentinelServersConfig serverConfig = config.useSentinelServers()
                .addSentinelAddress(newNodes.toArray(new String[0]))
                .setMasterName(redisModel.getSentinel().getMaster())
                .setReadMode(ReadMode.SLAVE)
                .setTimeout(redisModel.getTimeout());
        // 设置密码
        if(StringUtils.isNotBlank(redisModel.getPassword())){
            serverConfig.setPassword(redisModel.getPassword());
        }
        // 设置database
        if (redisModel.getDatabase()!=0){
            serverConfig.setDatabase(redisModel.getDatabase());
        }
        return Redisson.create(config);
    }
}

四、使用

一个简单的使用方法示例

package com.zlc.distributedlocka;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.concurrent.TimeUnit;

@SpringBootApplication
public class DistributedlockAApplication {
    
    @Autowired
    private RedissonClient redissonClient;

    public static void main(String[] args) {
        SpringApplication.run(DistributedlockAApplication.class, args);
    }
    
    // 这里的锁是对哨兵模式下的database生效的，
    // 需要分布式锁的两个系统一定要使用同一哨兵模式的database
    // 如果一个使用默认0，一个使用1或者其他，是锁不住的
    private void TestLock(){
        boolean lockFlag = false;
        RLock rLock = null;
        try {
            // 使用redis中的某个key值作为获取分布式锁
            rLock = redissonClient.getLock("redisKey");
            //  第一个参数为等待时间，第二个参数为占有时间（单位都为毫秒）
            // 等待时间为如果没有通过redisKey获取到锁，则等待1s,1s后还没获取到锁，则tryLock返回false，表明有人正在使用
            // 如果直接获取到锁了，则表明没有人使用，设置了你占有他的时间为5s
            lockFlag = rLock.tryLock(1000, 5000, TimeUnit.MILLISECONDS);
            if (lockFlag){
                // 获取到锁，进行数据处理或者其他操作
            }else {
                // 没有获取到锁，进行一些操作
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 如果锁没有释放，手动释放锁
            // 注意是使用isHeldByCurrentThread
            if (lockFlag && rLock.isHeldByCurrentThread()){
                rLock.unlock();
            }
        }
    }
}

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

相关文章

  • redis-trib.rb命令详解

    redis-trib.rb命令详解

    redis-trib.rb是官方提供的Redis Cluster的管理工具,无需额外下载,默认位于源码包的src目录下,但因该工具是用ruby开发的,所以需要准备相关的依赖环境,这篇文章主要介绍了redis-trib.rb命令详解,需要的朋友可以参考下
    2023-10-10
  • Redis源码分析之set 和 sorted set 使用

    Redis源码分析之set 和 sorted set 使用

    本文介绍了Redis 中的 set 和 sorted set 使用源码实现分析,Redis 的 Set 是 String 类型的无序集合，集合成员是唯一的，sorted set有序集合和集合一样也是 string 类型元素的集合，对Redis set 和 sorted set使用相关知识感兴趣的朋友一起看看吧
    2022-03-03
  • YII2框架手动安装Redis扩展的过程

    YII2框架手动安装Redis扩展的过程

    这篇文章主要介绍了YII2框架手动安装Redis扩展的过程，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2022-06-06
  • redis Template.opsForValue()中方法实例详解

    redis Template.opsForValue()中方法实例详解

    这篇文章主要介绍了redis Template.opsForValue()中方法讲解,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2023-05-05
  • 面试常问：如何保证Redis缓存和数据库的数据一致性

    面试常问：如何保证Redis缓存和数据库的数据一致性

    在实际开发过程中，缓存的使用频率是非常高的，只要使用缓存和数据库存储，就难免会出现双写时数据一致性的问题，那我们又该如何解决呢
    2021-09-09
  • Redis数据类型之散列类型hash命令学习

    Redis数据类型之散列类型hash命令学习

    这篇文章主要为大家介绍了Redis数据类型之散列类型hash命令学习，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-07-07
  • Redis 整数集合的具体使用(intset)

    Redis 整数集合的具体使用(intset)

    对于集合，STL 的 set 相信大家都不陌生，本文主要介绍了整数集合，又称为 intset，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-02-02
  • Redis利用互斥锁解决缓存击穿问题

    Redis利用互斥锁解决缓存击穿问题

    使用互斥锁可以有效防止缓存击穿的情况发生,它能够保证在缓存失效时,只有一个线程或者进程能够去加载数据,其余的请求都会等待这个加载过程完成,虽然这种方式会牺牲一部分性能,但它大大提高了系统的稳定性和可用性
    2024-08-08
  • Redis过期数据的删除策略详解

    Redis过期数据的删除策略详解

    Redis 是一个kv型数据库，我们所有的数据都是存放在内存中的，但是内存是有大小限制的，不可能无限制的增量，这篇文章主要介绍了Redis过期数据的删除策略,需要的朋友可以参考下
    2023-08-08
  • 关于在Redis中使用Pipelining加速查询的问题

    关于在Redis中使用Pipelining加速查询的问题

    这篇文章主要介绍了在Redis中使用Pipelining加速查询,Redis是一个client-server模式的TCP服务，也被称为Request/Response协议的实现，本文通过一个例子给大家详细介绍，感兴趣的朋友一起看看吧
    2022-05-05

最新评论