redis深度历险-分布式锁笔记

前言

之前复习和记录了一下redis的基础数据类型
今天看了一下这本书对于redis实现分布式锁的内容
感觉差不多也是一样的操作利用redis本身的特性做的单节点分布式锁和多节点分布式锁的处理

分布式锁:在分布式环境中对于资源锁定需要一个能共享的变量区域来存储资源的锁定状态从而处理相关资源
常用实现分布式锁的中间件有 redis、zk、etcd等等只要是能共享存储的可并发访问使用的都可以用来实现分布式锁 redis只是其中一种方案

实现分布式锁

一般项目中单机redis 即可满足使用要求
但是也存在分布式情况这里只考虑官方cluster分布式方案的分布式锁实现
只需要使用set 来加锁和设置时间 exists判断是否锁定 del主动删除锁

指令演示

#对一个名称为name的值为value的锁进行操作 
#加锁 此处使用redis2.8之后对set的扩展命令    扩展ex nx 使set同时具有 set+ex+nx 功能 
set name value ex 5 nx 
#判断锁是否存在
exists name 
#主动释放锁
del name

单机模式

java实现代码

直接使用 redisTemplate来操作

package com.ming.base;

import com.ming.core.utils.SpringBeanManager;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * redis 实现单节点分布式锁
 * {@linkplain com.ming.core.utils.SpringBeanManager 操作spring容器中的bean的工具类}
 *
 * @author ming
 * @date 2019-09-02 13:54:42
 */
@Slf4j
public class RedisLock {

    /**
     * 默认超时时间
     */
    private static final long DEFAULT_EXPIRE = 10;

    /**
     * 加锁
     *
     * @author ming
     * @date 2019-09-02 13:57:16
     */
    public static void lock(String key) {
        lock(key, System.currentTimeMillis() + "", DEFAULT_EXPIRE);
    }

    /**
     * 加锁
     *
     * @author ming
     * @date 2019-09-02 13:57:16
     */
    public static void lock(String key, Long expire) {
        lock(key, System.currentTimeMillis() + "", expire);
    }

    /**
     * 加锁
     *
     * @author ming
     * @date 2019-09-02 13:57:16
     */
    public static void lock(String key, String value) {
        lock(key, value, DEFAULT_EXPIRE);
    }

    /**
     * 加锁
     *
     * @author ming
     * @date 2019-09-02 13:57:16
     */
    public static void lock(String key, String value, Long expire) {
        log.debug("加锁,key{},value{},超时时间:{}s", key, value, expire);
        if (!Objects.requireNonNull(getClient().opsForValue().setIfAbsent(key, value, expire, TimeUnit.SECONDS), "加锁返回异常")) {
            throw new RuntimeException("加锁失败、已经锁定");
        }
    }


    /**
     * 释放锁
     *
     * @author ming
     * @date 2019-09-02 13:57:26
     */
    public static void unLock(String key) {
        log.debug("释放锁,key{}", key);
        getClient().delete(key);
    }

    /**
     * 获取 redis client
     *
     * @author ming
     * @date 2019-09-02 14:02:29
     */
    private static StringRedisTemplate getClient() {
        return SpringBeanManager.getBean(StringRedisTemplate.class);
    }
}

测试用例

package com.ming;

import com.ming.base.RedisLock;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * redis lock 测试
 *
 * @author ming
 * @date 2019-09-02 14:15:50
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Start.class)
public class RedisLockTest {
    @Test
    public void test(){
        //加锁
        RedisLock.lock("ming");
        //继续加锁
        try{
            RedisLock.lock("ming");
        }catch (RuntimeException e){
            e.printStackTrace();
        }
        //释放锁
        RedisLock.unLock("ming");
        //加锁
        RedisLock.lock("ming");
        RedisLock.unLock("ming");
    }

}

cluster集群模式

分布式情况下使用 redisson来实现分布式锁避免由于集群的同步、故障等问题引起分布式锁异常
参考文档: https://github.com/redisson/redisson
大佬解析隐含的坑博客:https://www.jianshu.com/p/b12e1c0b3917

maven配置

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

java实现代码

package com.ming.base;

import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

/**
 * redis 通过redisson实现分布式redis集群的分布式锁
 *
 * @author ming
 * @date 2019-09-02 13:54:42
 */
@Slf4j
public class RedissonLock {

    /**
     * 默认超时时间
     */
    public static final long DEFAULT_EXPIRE = 100;

    /**
     * 获取 redis client
     * 此处仅限于测试使用 如果是正式使用 请建立客户端单例 来使用
     *
     * @author ming
     * @date 2019-09-02 14:02:29
     * @see <a href="https://github.com/redisson/redisson/wiki">redisson wiki </a>
     */
    public static RedissonClient getClient() {
        Config config = new Config();
        //cluster 模式集群 配置
//        config.useClusterServers()
//                //扫描间隔时间 毫秒
//                .setScanInterval(1000)
////                .addNodeAddress("redis://127.0.0.1:6379","redis://127.0.0.1:6380","redis://127.0.0.1:6381")
//                .addNodeAddress("redis://192.168.1.179:6379");
        //单实例配置
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);

    }
}

测试用例

package com.ming;

import com.ming.base.RedissonLock;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.redisson.api.RLock;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.TimeUnit;

/**
 * redisson lock 测试
 *
 * @author ming
 * @date 2019-09-02 14:15:50
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Start.class)
public class RedissonLockTest {
    @Test
    public void test() throws InterruptedException {
        String key = "ming";
        //加锁
        RLock lock = RedissonLock.getClient().getLock(key);
        lock.lock(RedissonLock.DEFAULT_EXPIRE, TimeUnit.SECONDS);
//        Thread.sleep(10000);
//        lock.lock(RedissonLock.DEFAULT_EXPIRE, TimeUnit.SECONDS);
//        lock.unlock();
//        lock.lock(RedissonLock.DEFAULT_EXPIRE, TimeUnit.SECONDS);

        System.out.println(System.currentTimeMillis());
    }

}

注意

超时

超时时间一定要根据生产运行情况进行预估配置

个人习惯配置为: max(资源执行最大耗时)*130%

锁的超时时间:
最小值:这个资源最大操作时间

如果预估不准建议初始设置长一点根据生产运行情况进行合适的调整

最大值:业务允许的最大超时时间或者硬件能支撑的最大时间

一般会有操作此项业务最大超时时间如果没有可以根据硬件的资源情况估计

可重入性

一般来说锁肯定需要考虑重入性
但是分布式锁这种本身就比较麻烦的东西一般建议从业务上考虑避开重入锁
当然如果无法避开就只能在key上加上计数器来做重入性锁了
然后由于 redis本身单个命令是原子操作但是组合使用就gg了
如果非要需要自定义lua脚本实现redis定制命令来配合实现可重入的锁

1	eval "lua脚本"

redis在执行lua脚本的时候会当成一个整体执行不存在竞态条件

或者直接使用redisson 的RedissonLock 来做

总结

redis 本身性能强劲不考虑高可用大多数情况下单机够用
redis 用来共享数据做分布式锁也是很适合性能高、单线程执行、可用lua脚本扩充功能
分布式锁本身没有什么特殊性就是需要一个性能好、可控制并发访问的地方存储就行
redis、zk、etcd 等等只要能存数据并且有良好的并发访问控制的中间件都可以实现
redisson 用起来麻烦点但是胜在用的人多考虑的完全适配单机、分布式各种环境
手写的话只适合自嗨其实并没有什么卵用