手把手教学Redisson实现分布式锁

1、分布式锁产生的背景

    在系统单体架构下不会存在分布式锁的问题，通过JVM提供的synchronized 或  JUC中提供的ReentrantLock 就可以满足当前业务加锁需求，当随着业务发展，采用系统采用集群部署后，多个节点下相互独立，此刻用JVM提供的锁就无法在并发场景下锁住资源，需要采用分布式中间件来实现。

项目实践中分布式锁的常见解决方案：

1. 基于数据库实现分布式锁

2. 基于缓存（Redis等）实现分布式锁

3. 基于Zookeeper实现分布式锁

特别注意：本篇文章中使用的Redisson 也是基于"Redis" 实现RedissonClient 进行加锁操作的。

2、引入Redisson依赖的Jar包

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

3、项目工程中添加Redisson配置类

spring:
  redis:
    timeout: 6000ms
    password: 
    cluster:
      max-redirects: 1
      nodes:
        - 10.98.66.65:6379
        - 10.98.66.66:6379
        - 10.98.66.67:6379

package com.demo.configuration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;

/**
 * @author youyun.xu
 * @ClassName: RedisConfigProperties
 * @Description: 读取Reids配置字段值
 * @date 2020/10/22 15:26
 */
@Component
@ConfigurationProperties(prefix = "spring.redis")
public class RedisConfigProperties {

    private String password;
    private cluster cluster;

    public static class cluster {
        private List<String> nodes;

        public List<String> getNodes() {
            return nodes;
        }

        public void setNodes(List<String> nodes) {
            this.nodes = nodes;
        }
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public RedisConfigProperties.cluster getCluster() {
        return cluster;
    }

    public void setCluster(RedisConfigProperties.cluster cluster) {
        this.cluster = cluster;
    }
}

package com.demo.configuration;

import org.redisson.Redisson;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

/**
 * @author youyun.xu
 * @ClassName: RedissonConfigure
 * @Description: Redisson 客户端（实现分布式锁）
 * @date 2020/10/22 15:26
 */
@Configuration
public class RedissonConfigure {

    @Autowired
    private RedisConfigProperties redisConfigProperties;

    @Bean
    public Redisson redisson() {
        List<String> clusterNodes = new ArrayList<>();
        for (int i = 0; i < redisConfigProperties.getCluster().getNodes().size(); i++) {
            clusterNodes.add("redis://" + redisConfigProperties.getCluster().getNodes().get(i));
        }
        Config config = new Config();
        /**
         * 单机
         */
        //config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("xxx");

        /**
         * 哨兵
         */
        //config.useSentinelServers().addSentinelAddress("");

        /**
         * 集群
         */
        config.useClusterServers().addNodeAddress(clusterNodes.toArray(new String[clusterNodes.size()]));
        return (Redisson) Redisson.create(config);
    }
}

4、项目工程中使用Redisson锁住资源

package com.demo.configuration;

import com.tcl.uf.common.base.dto.ResponseData;
import com.tcl.uf.marketing.utils.RedisUtils;
import io.swagger.annotations.Api;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @author youyun.xu
 * @ClassName: DemoController
 * @Description: Redis 和 Redisson 工具测试
 * @date 2020/10/22 15:59
 */
@RestController
@RequestMapping("/demo")
@Api(tags = "Redisson 测试工具类")
public class DemoController {

    private static final Logger _logger = LoggerFactory.getLogger(DemoController.class);

    @Autowired
    private Redisson redisson;

    //总库存为100张票
    private static int ticket = 100;

    /**
     * 功能：分布式锁应用(使用jmeter并发请求)
     * 描述：
     *
     * @return ResponseData
     * @throws Exception
     */
    @RequestMapping(value = "/use/distributedLock")
    public ResponseData distributedLock() throws Exception {
        long threadId = Thread.currentThread().getId();
        /*
         * 1.加锁设置(获取锁等待时间、占用锁等待时间)
         * 2.释放锁(不管业务执行成功或失败都需要释放锁)
         * 3.锁的粒度可以根据自己业务定制
         * */
        RLock lock = redisson.getLock("DISTRIBUTED_LOCK_KEY_DEMO");
        if (lock.tryLock(10, 10, TimeUnit.SECONDS)) {
            try {
                if (ticket > 0) {
                    ticket--;
                    _logger.info("获得锁(出票成功) tryLock thread--{}, lock {} ticket count {}", threadId, lock, ticket);
                } else {
                    _logger.info("获得锁(已售罄) tryLock thread--{}, lock {} ticket count {}", threadId, lock, ticket);
                }
            } catch (Exception e) {
                _logger.error("执行业务出错 business error thread---{}, lock {} exception {}", threadId, lock);
            } finally {
                _logger.info("释放锁 unlock thread--{} lock {}", threadId, lock);
                lock.unlock();
            }
        } else {
            _logger.info("获取锁失败(请稍后重试) fail thread--{} lock {}", threadId, lock);
        }
        return new ResponseData();
    }
}

5、项目工程中使用Redisson注意事项

1、加锁是有2个时间需要注意区分，结合业务场景设定：

      获取锁等待时间(waitTime)  "获取这把锁愿意等多久"

      占用锁时间(leaseTime)       "获取锁后占用使用多久"

2、Redisson 引入看门狗机制：

     如第一点设置占用锁时间(leaseTime)，但实际业务执行过程中超过设定的leaseTime，看门狗会自动续上30s,不用担心业务时间长，锁自动过期被删掉（默认延长30秒、只延长1次）

     看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。

6、思考题

集群模式下：Redis集群中选择一台master实例去实现锁机制，如果master和salve同步的过程中，master宕机了，偏偏在这之前某个服务实例刚刚写入了一把锁，salve还没有同步到这把锁，就被切换成了master，另一个服务实例在新的master上获取到一把新锁，这时候就会出现俩台服务实例都持有锁，执行业务逻辑的场景，这个是有问题的，该如何解决呢？