分布式锁：有关于分布式锁合集(四)

本片文章为 分布式锁 相关的系列文章

​ 本系列文章 将从 缓存的使用 本地锁 ** 一直写到 **分布式锁 以及相关的一些 知识点 问题

上一篇文章说明了八种Redisson 分布式锁和同步器的基本用法 本章将详细讲解如何使用Redisson做分布式锁

上一篇文章：“分布式锁：有关于分布式锁集合（三）”

Redisson 的 快速入门

// 1. Create config object
// 创建一个配置类对象 （那么我前面肯定就现需要有一个配置类或者配置文件）
Config config = new Config();
config.useClusterServers()
       // use "rediss://" for SSL connection
      .addNodeAddress("redis://127.0.0.1:7181");

// or read config from file
// 配置信息 可以 通过 配置文件获取
config = Config.fromYAML(new File("config-file.yaml")); 

// 2. Create Redisson instance
// 创建Redisson实例对象
// Sync and Async API
// 使用静态 非静态的 api方法
RedissonClient redisson = Redisson.create(config);

// Reactive API
RedissonReactiveClient redissonReactive = Redisson.createReactive(config);

// RxJava2 API
RedissonRxClient redissonRx = Redisson.createRx(config);

// 3. Get Redis based implementation of java.util.concurrent.ConcurrentMap
RMap<MyKey, MyValue> map = redisson.getMap("myMap");

RMapReactive<MyKey, MyValue> mapReactive = redissonReactive.getMap("myMap");

RMapRx<MyKey, MyValue> mapRx = redissonRx.getMap("myMap");

// 4. Get Redis based implementation of java.util.concurrent.locks.Lock
// 获得 redis lock锁对象
RLock lock = redisson.getLock("myLock");

RLockReactive lockReactive = redissonReactive.getLock("myLock");

RLockRx lockRx = redissonRx.getLock("myLock");

// 4. Get Redis based implementation of java.util.concurrent.ExecutorService
// 获得 redis 基础 执行服务
RExecutorService executor = redisson.getExecutorService("myExecutorService");

// over 50 Redis based Java objects and services ...

看 官方文档 是不是有点 懵懵的 没事 看下面慢慢捋

// 自己定义的配置类
@Data
@Configuration
@ConfigurationProperties("spring.redis")
public class RedissonConfig {

    private String host;

    private String addresses;

    private String password;

    private String port;

    private int timeout = 3000;
    private int connectionPoolSize = 64;
    private int connectionMinimumIdleSize=10;
    private int pingConnectionInterval = 60000;
    private static String ADDRESS_PREFIX = "redis://";

    /**
     * 自动装配
     *
     */
    @Bean        // 返回一个 RedissonClient  意味着 注入进容器的 直接调用即可用
    RedissonClient redissonSingle() {   
        Config config = new Config();

        if(StringUtils.isEmpty(host)){
            throw new RuntimeException("host is  empty");
        }
        // useSingleServer ：单机
        // clusterServersConfig ：集群
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(ADDRESS_PREFIX + this.host + ":" + port) // 设置ip地址端口号
                .setTimeout(this.timeout)                            // 设置 超时时间
                .setPingConnectionInterval(pingConnectionInterval)  // redis 命令发送时间间隔
                .setConnectionPoolSize(this.connectionPoolSize)     // redis 连接池大小
                .setConnectionMinimumIdleSize(this.connectionMinimumIdleSize); // redis 最小空闲的链接数量
        if(!StringUtils.isEmpty(this.password)) {
            serverConfig.setPassword(this.password);
        }
        // RedissonClient redisson = Redisson.create(config);
        // 直接 将 拿到的RedissonClient 直接 返回回去 注入 spring IOC 容器
        return Redisson.create(config);
    }
}

@Service
public class TestServiceImpl implements TestService {

    @Autowired
    private RedissonClient redissonClient;

    // 使用 redisson 做 分布式锁
    @Override
    public void testLock() {
        // 1. 拿到redissonClient 使用getLock(传入锁) 得到 RLock 可重入锁 对象
        RLock lock = redissonClient.getLock("lock");
        // 2. 使用 锁对象 上锁
        lock.lock();
        // 执行业务逻辑
        // 3. 解锁
        lock.unlock();
    }
}

// redisson 的 三种 加锁方式
// 1. lock.lock();  和 lock.unlock(); 成对出现
// 2. lock.lock(设置过期时间，TimeUnit.SECONDS)； 不需要手动释放锁
// 3. lock.tryLock(最大等待时间，设置过期时间，TimeUnit.SECONDS)； 需要在finally里面 设置解锁
@Service
public class TestServiceImpl implements TestService {

    @Autowired
    private RedissonClient redissonClient;

    // 使用 redisson 做 分布式锁
    @Override
    public void testLock() {
        // 1. 拿到redissonClient 使用getLock(传入锁) 得到 RLock 可重入锁 对象
        RLock lock = redissonClient.getLock("lock");
        // 2. 使用 锁对象 上锁
        //lock.lock();
        //lock.lock(10,TimeUnit.SECONDS); // 添加过期时间
        try {
            // 设置 过期时间
            boolean result = lock.tryLock( 10, TimeUnit.SECONDS);

            if (result) {
                // 获得 锁 成功

                // 执行业务逻辑
                // 查询redis中的num值
                // 直接获取缓存中的数据
                String value = (String)this.redisTemplate.opsForValue().get("num");
                // 没有该值return
                if (StringUtils.isBlank(value)){
                    return ;
                }
                // 有值就转成成int
                int num = Integer.parseInt(value);
                // 把redis中的num值+1
                this.redisTemplate.opsForValue().set("num", String.valueOf(++num));
            } else {
                // 失败 去数据库查 自旋
                try {
                    Thread.sleep(500);
                    testLock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }

        // 3. 解锁
        //lock.unlock();
    }

使用ab压力测试工具

启动网关微服务 使用网关 启用负载均衡 访问数据

ab -n 5000 -c
100 http://192.168.200.1/admin/product/test/testLock

使用redis桌面管理工具连接上此redis 最后显示的num数为 5000 上锁成功

总结

• 常见的分布式锁 两种

• 基于数据库 但是效率低 不使用

• 基于缓存redis

  • redis + lua脚本 单机情况下够用 但是在 集群环境下失效
  • redisson

• 基于zookeeper

赏

谢谢你请我吃糖果