Redis：Redlock思路

最新推荐文章于 2024-05-07 23:51:50 发布

寿命齿轮

最新推荐文章于 2024-05-07 23:51:50 发布

阅读量53

点赞数

分类专栏： redis学习文章标签： redis 数据库缓存

本文链接：https://blog.csdn.net/lifetime_gear/article/details/132848413

版权

redis学习专栏收录该内容

25 篇文章 0 订阅

订阅专栏

本文将介绍Redis分布锁的Redlock红锁算法思路和在Redisson中的对应实现。

Redlock

相较于原先我们自己写的分布式锁只能运行在一个master上进而导致可能由master宕机引起一锁多用问题，Redlock选择了将锁同时存放在不同的master中，通过多份备份保证分布式系统中的锁的独占性。

详细流程：

假设我们有N个Redis主节点，例如 N = 5这些节点是完全独立的，我们不使用复制或任何其他隐式协调系统，为了取到锁客户端执行以下操作：

获取当前时间，以毫秒为单位。
依次尝试从5个实例，使用相同的 key 和随机值（例如 UUID）获取锁。当向Redis 请求获取锁时，客户端应该设置一个超时时间，这个超时时间应该小于锁的失效时间。例如你的锁自动失效时间为 10 秒，则超时时间应该在 5-50 毫秒之间。这样可以防止客户端在试图与一个宕机的 Redis 节点对话时长时间处于阻塞状态。如果一个实例不可用，客户端应该尽快尝试去另外一个 Redis 实例请求获取锁。
客户端通过当前时间减去步骤 1 记录的时间来计算获取锁使用的时间。当且仅当从大多数（N/2+1，这里是 3 个节点）的 Redis 节点都取到锁，并且获取锁使用的时间小于锁失效时间时，锁才算获取成功。
如果取到了锁，其真正有效时间等于初始有效时间减去获取锁所使用的时间（步骤 3 计算的结果）。
如果由于某些原因未能获得锁（无法在至少 N/2 + 1 个 Redis 实例获取锁、或获取锁的时间超过了有效时间），客户端应该在所有的 Redis 实例上进行解锁（即便某些Redis实例根本就没有加锁成功，防止某些节点获取到锁但是客户端没有得到响应而导致接下来的一段时间不能被重新获取锁）。

这样一个锁就会存在于N/2+1个实例中，进而保证即使有节点宕机，一个锁已经分配完成后，其他人是无法再持有锁的（无法做到在N/2+1个master实例中获取锁）。

同时，这样还增加了服务的可用性，当存在n台master宕机的情形下，只要其他的n+1或n+2台master没有宕机，即可继续提供锁服务。

存在应用性问题

redis通常是集群或哨兵部署，哨兵情况下只有单台master，无法使用Redlock算法；集群情况下，缓存数据会进行分片存储，每个master只负责对应的槽位，但是Redlock需要分布在多台master上，就意味着Redlock必须找到合适的多个key，才能存储到多台master中，否则就要求必须存在多台单点master。

Redisson中的Multilock

Redisson中实现了Redlock算法，可直接调用，不过现在推荐使用的是Multilock（Redlock存在上述应用性问题，无法实现让lock分布在redis集群中，所以已被弃用），并且同样不支持redis集群，尽可在多台单点redis中使用。（如果在集群中用，就需要手动分配锁，这是相当麻烦的一件事）

导入依赖：

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

在application.yml中准备好多个单点redis的ip、端口号和连接池的属性：

spring.redis.single.address1=192.168.111.185:6381

spring.redis.single.address2=192.168.111.185:6382

spring.redis.single.address3=192.168.111.185:6383

spring.redis.database=0

spring.redis.password=

spring.redis.timeout=3000

spring.redis.mode=single

spring.redis.pool.conn-timeout=3000

spring.redis.pool.so-timeout=3000

spring.redis.pool.size=10

创建实体类用于存储yml中数据：

@Data
public class RedisPoolProperties {

    private int maxIdle;

    private int minIdle;

    private int maxActive;

    private int maxWait;

    private int connTimeout;

    private int soTimeout;
    private  int size;//池大小
}
@Data
public class 
RedisSingleProperties {    
    private String address1;
    private String address2;
    private String address3;
}
@ConfigurationProperties(prefix = "spring.redis", ignoreUnknownFields = false)
@Data
public class RedisProperties {

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

    private String password;

    private String mode;
    private RedisPoolProperties pool;//池配置
    private RedisSingleProperties single;//单机信息配置


}

初始化好3个redis：

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class CacheConfiguration {

    @Autowired
    RedisProperties redisProperties;

    @Bean
    RedissonClient redissonClient1() {
        Config config = new Config();
        String node = redisProperties.getSingle().getAddress1();
        node = node.startsWith("redis://") ? node : "redis://" + node;
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(node)
                .setTimeout(redisProperties.getPool().getConnTimeout())
                .setConnectionPoolSize(redisProperties.getPool().getSize())
                .setConnectionMinimumIdleSize(redisProperties.getPool().getMinIdle());
        if (StringUtils.isNotBlank(redisProperties.getPassword())) {
            serverConfig.setPassword(redisProperties.getPassword());
        }
        return Redisson.create(config);
    }

    @Bean
    RedissonClient redissonClient2() {
        Config config = new Config();
        String node = redisProperties.getSingle().getAddress2();
        node = node.startsWith("redis://") ? node : "redis://" + node;
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(node)
                .setTimeout(redisProperties.getPool().getConnTimeout())
                .setConnectionPoolSize(redisProperties.getPool().getSize())
                .setConnectionMinimumIdleSize(redisProperties.getPool().getMinIdle());
        if (StringUtils.isNotBlank(redisProperties.getPassword())) {
            serverConfig.setPassword(redisProperties.getPassword());
        }
        return Redisson.create(config);
    }

    @Bean
    RedissonClient redissonClient3() {
        Config config = new Config();
        String node = redisProperties.getSingle().getAddress3();
        node = node.startsWith("redis://") ? node : "redis://" + node;
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(node)
                .setTimeout(redisProperties.getPool().getConnTimeout())
                .setConnectionPoolSize(redisProperties.getPool().getSize())
                .setConnectionMinimumIdleSize(redisProperties.getPool().getMinIdle());
        if (StringUtils.isNotBlank(redisProperties.getPassword())) {
            serverConfig.setPassword(redisProperties.getPassword());
        }
        return Redisson.create(config);
    }
}

即可调用multiLock：multiLock与redlock不同的是，redlock只需要N/2+1个锁获得回应即可，multilock需要全部的锁都获得。

@Autowired
RedissonClient redissonClient1;

@Autowired
RedissonClient redissonClient2;
@Autowired
RedissonClient redissonClient3;

boolean isLockBoolean;

@GetMapping(value = "/multiLock")
public String getMultiLock() throws InterruptedException
{
    String uuid =  IdUtil.simpleUUID();
    String uuidValue = uuid+":"+Thread.currentThread().getId();

    RLock lock1 = redissonClient1.getLock(CACHE_KEY_REDLOCK);
    RLock lock2 = redissonClient2.getLock(CACHE_KEY_REDLOCK);
    RLock lock3 = redissonClient3.getLock(CACHE_KEY_REDLOCK);

    RedissonMultiLock redLock = new RedissonMultiLock(lock1, lock2, lock3);
    redLock.lock();
    try{
        System.out.println(uuidValue+"\t"+"---come in biz multiLock");
        try { TimeUnit.SECONDS.sleep(30); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println(uuidValue+"\t"+"---task is over multiLock");
    } catch (Exception e) {
        e.printStackTrace();
        log.error("multiLock exception ",e);
    } finally {
        redLock.unlock();
        log.info("释放分布式锁成功key:{}", CACHE_KEY_REDLOCK);
    }

    return "multiLock task is over  "+uuidValue;
}