Java项目集成Redisson分布式锁

---

前言

一、为什么需要分布式锁？

因为Java中的锁，只作用于单个JVM实例上。而当下在互联网技术架构中，大家都用的分布式架构了，应用部署到多个服务器，这种情况下，线程之间的锁机制，就没作用了。为了解决这个问题，我们就引入分布式锁。

二、分布式锁要满足哪些要求呢？

（1）排他性：在同一时间只会有一个客户端能获取到锁，其它客户端无法同时获取。
（2）避免死锁：这把锁在一段有限的时间之后，一定会被释放。
（3）高可用：获取或释放锁的机制必须高可用且性能佳。

三、分布式锁的实现方式

这里只讲基于Redis实现的分布式锁，需要引入Redisson。

1.引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>${redisson.version}</version>
</dependency>

2.配置类

@Configuration
public class RedissonConfig {
    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private String port;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.database}")
    private Integer database;

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer().setDatabase(database).setAddress("redis://" + host + ":" + port);
        if (StrUtil.isNotBlank(password)) {
            config.useSingleServer().setPassword(password);
        }
        return Redisson.create(config);
    }
}

3.配置文件

spring:
	redis:
	    host: 127.0.0.1
	    port: 6379
	    password: 
	    database: 0        # Redis数据库索引（默认为0）
	    lettuce:
	      pool:
	        max-active: 8   # 连接池最大连接数(使用负值表示没有限制) (默认为8)

4.RedissonService

@Service
@Slf4j
@RequiredArgsConstructor
public class RedissonService {
    private final RedissonClient redissonClient;

    /**
     * 加锁
     *
     * @param lockKey
     * @return
     */
    public RLock lock(String lockKey) {
        RLock rLock = redissonClient.getLock(lockKey);
        rLock.lock();
        return rLock;
    }

    /**
     * 加锁
     *
     * @param lockKey
     * @param timeout 超时时间，单位：秒
     * @return
     */
    public RLock lock(String lockKey, int timeout) {
        RLock rLock = redissonClient.getLock(lockKey);
        rLock.lock(timeout, TimeUnit.SECONDS);
        return rLock;
    }

    /**
     * 尝试获取锁
     *
     * @param lockKey
     * @return
     */
    public boolean tryLock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock();
    }

    /**
     * 尝试获取锁
     *
     * @param lockKey
     * @param waitTime 最多等待时间
     * @return
     */
    public boolean tryLock(String lockKey, int waitTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 尝试获取锁
     *
     * @param lockKey
     * @param waitTime  最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @return
     */
    public boolean tryLock(String lockKey, int waitTime, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 解锁
     *
     * @param lockKey
     */
    public void unlock(String lockKey) {
        RLock rLock = redissonClient.getLock(lockKey);
        if (rLock.isLocked() && rLock.isHeldByCurrentThread()) {
            rLock.unlock();
        }
    }
}

5.RedissonController

@RestController
@Slf4j
public class RedissonController {
    @Resource
    private RedissonService redissonService;

    @GetMapping("test")
    public void test() {
        String lockKey = "test:" + 666;
        if (!redissonService.tryLock(lockKey, 5)) {
            throw new RuntimeException("请稍后重试");
        }
        try {
            log.info("执行业务逻辑");
        } catch (Exception e) {
            log.error("异常", e);
        } finally {
            redissonService.unlock(lockKey);
        }
        return "success";
    }
}

四、总结

Lock和tryLock的区别

1. lock拿不到锁会一直等待；tryLock是去尝试，拿不到就返回false，拿到返回true。
2. tryLock是可以被打断的，被中断的，lock是不可以。

名称	描述
lock.lock()	具有Watch Dog自动延期机制，默认续30s，每隔30/3=10 秒续到30s
lock.lock(10, TimeUnit.SECONDS)	没有Watch Dog ，10s后自动释放
lock.tryLock(10, TimeUnit.SECONDS)	尝试拿锁10s后停止重试，返回false，具有Watch Dog自动延期机制，默认续30s
lock.tryLock(10, 100, TimeUnit.SECONDS)	尝试拿锁100s后停止重试，返回false，有Watch Dog ，100s后自动释放