基于redis使用redisson实现分布式锁

最近的项目中要用到分布式锁，而且redis的官方文档也推荐redisson作为分布式锁，所以记录下项目中具体的使用。

1.引入redisson依赖：

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

2.定义一个Loker接口，用于分布式锁的一些操作：

package com.lbd99.scm.pre.util.redisson;

import java.util.concurrent.TimeUnit;

/**
 * Redisson锁接口
 *
 * @author Tom
 * @date 2019-11-15
 */
public interface Locker {

    /**
     * 获取锁，如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。
     *
     * @param lockKey 唯一加锁字段
     */
    void lock(String lockKey);

    /**
     * 释放锁
     *
     * @param lockKey 唯一加锁字段
     */
    void unlock(String lockKey);

    /**
     * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁
     *
     * @param lockKey 唯一加锁字段
     * @param timeout 超时时间(到超时时间后会自动释放锁)
     */
    void lock(String lockKey, int timeout);

    /**
     * 获取锁,如果锁不可用，则当前线程处于休眠状态，直到获得锁为止。如果获取到锁后，执行结束后解锁或达到超时时间后会自动释放锁
     *
     * @param lockKey 唯一加锁字段
     * @param unit 时间设置字段(一般使用TimeUnit.SECONDS,表示秒)
     * @param timeout 超时时间(到超时时间后会自动释放锁)
     */
    void lock(String lockKey, TimeUnit unit, int timeout);

    /**
     * 尝试获取锁，获取到立即返回true,未获取到立即返回false
     *
     * @param lockKey 唯一加锁字段
     * @return
     */
    boolean tryLock(String lockKey);

    /**
     * 尝试获取锁，在等待时间内获取到锁则返回true,否则返回false,如果获取到锁，则要么执行完后程序释放锁，
     * 要么在给定的超时时间leaseTime后释放锁
     *
     * @param lockKey 唯一加锁字段
     * @param waitTime 等待时间(此时间段会获取锁)
     * @param leaseTime 超时时间(获取到锁后,如果到达超时时间还没有释放锁,将会自动释放锁)
     * @param unit 时间设置字段(一般使用TimeUnit.SECONDS,表示秒)
     * @return
     */
    boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit)
            throws InterruptedException;

    /**
     * 锁是否被任意一个线程锁持有
     *
     * @param lockKey 唯一加锁字段
     * @return
     */
    boolean isLocked(String lockKey);

}

3.再添加一个基于Redisson的实现类RedissonLocker：

package com.lbd99.scm.pre.util.redisson;

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import java.util.concurrent.TimeUnit;

/**
 * 基于Redisson的分布式锁实现类
 *
 * @author Tom
 * @date 2019-11-15
 */
public class RedissonLocker implements Locker {

    private RedissonClient redissonClient;

    public RedissonLocker(RedissonClient redissonClient) {
        super();
        this.redissonClient = redissonClient;
    }

    @Override
    public void lock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock();
    }

    @Override
    public void unlock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.unlock();
    }

    @Override
    public void lock(String lockKey, int leaseTime) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(leaseTime, TimeUnit.SECONDS);
    }

    @Override
    public void lock(String lockKey, TimeUnit unit, int timeout) {
        RLock lock = redissonClient.getLock(lockKey);
        lock.lock(timeout, unit);
    }

    public void setRedissonClient(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    @Override
    public boolean tryLock(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock();
    }

    @Override
    public boolean tryLock(String lockKey, long waitTime, long leaseTime,
                           TimeUnit unit) throws InterruptedException{
        RLock lock = redissonClient.getLock(lockKey);
        return lock.tryLock(waitTime, leaseTime, unit);
    }

    @Override
    public boolean isLocked(String lockKey) {
        RLock lock = redissonClient.getLock(lockKey);
        return lock.isLocked();
    }
}

4.我们定义一个工具类LockUtil，便于直接使用：

package com.lbd99.scm.pre.util.redisson;

import java.util.concurrent.TimeUnit;

/**
 * redisson分布式锁工具类
 *
 * @author Tom
 * @date 2019-11-15
 */
public class LockUtil {

    private static Locker locker;

    /**
     * 设置工具类使用的locker
     * @param locker
     */
    public static void setLocker(Locker locker) {
        LockUtil.locker = locker;
    }

    /**
     * 获取锁
     * @param lockKey 唯一加锁字段
     */
    public static void lock(String lockKey) {
        locker.lock(lockKey);
    }

    /**
     * 释放锁
     * @param lockKey 唯一加锁字段
     */
    public static void unlock(String lockKey) {
        locker.unlock(lockKey);
    }

    /**
     * 获取锁，超时释放
     * @param lockKey 唯一加锁字段
     * @param timeout 超时时间(到超时时间后会自动释放锁)
     */
    public static void lock(String lockKey, int timeout) {
        locker.lock(lockKey, timeout);
    }

    /**
     * 获取锁，超时释放，指定时间单位
     * @param lockKey 唯一加锁字段
     * @param unit 时间设置字段(一般使用TimeUnit.SECONDS,表示秒)
     * @param timeout 超时时间(到超时时间后会自动释放锁)
     */
    public static void lock(String lockKey, TimeUnit unit, int timeout) {
        locker.lock(lockKey, unit, timeout);
    }

    /**
     * 尝试获取锁，获取到立即返回true,获取失败立即返回false
     * @param lockKey 唯一加锁字段
     * @return
     */
    public static boolean tryLock(String lockKey) {
        return locker.tryLock(lockKey);
    }

    /**
     * 尝试获取锁，在给定的waitTime时间内尝试，获取到返回true,获取失败返回false,获取到后再给定的leaseTime时间超时释放
     * @param lockKey 唯一加锁字段
     * @param waitTime 等待时间(此时间段会获取锁)
     * @param leaseTime 超时时间(获取到锁后,如果到达超时时间还没有释放锁,将会自动释放锁)
     * @param unit 时间设置字段(一般使用TimeUnit.SECONDS,表示秒)
     * @return
     * @throws InterruptedException
     */
    public static boolean tryLock(String lockKey, long waitTime, long leaseTime,
                                  TimeUnit unit) throws InterruptedException {
        return locker.tryLock(lockKey, waitTime, leaseTime, unit);
    }

    /**
     * 锁释放被任意一个线程持有
     * @param lockKey 唯一加锁字段
     * @return
     */
    public static boolean isLocked(String lockKey) {
        return locker.isLocked(lockKey);
    }
}

5.创建一个redisson的配置类RedissonConfig：

package com.lbd99.scm.pre.configurations;

import com.lbd99.scm.pre.util.redisson.LockUtil;
import com.lbd99.scm.pre.util.redisson.RedissonLocker;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.io.IOException;

/**
 * Redisson配置类
 *
 * @author Tom
 * @date 2019-11-15
 */
@Configuration
public class RedissonConfig {

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

    /**
     * RedissonClient,单机模式
     * @return
     * @throws IOException
     */
    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() throws IOException {
        Config config = new Config();
        /**此处要注意，如果redis设置了密码,则需要加.setPassword("redis密码")*/
        config.useSingleServer().setAddress("redis://" + host + ":" + port);
        return Redisson.create(config);
    }

    @Bean
    public RedissonLocker redissonLocker(RedissonClient redissonClient){
        RedissonLocker locker = new RedissonLocker(redissonClient);
        /**设置LockUtil的锁处理对象*/
        LockUtil.setLocker(locker);
        return locker;
    }
}

6.项目中具体的使用(建议使用tryLock操作)：

/**使用Redisson加锁*/
LockUtil.tryLock(orderCode);
try {
    //TODU 具体的操作方法,注意在方法内若判断是否存在，需要先查询再判断
} finally {
    /**使用Redisson释放锁*/
    LockUtil.unlock(orderCode);
}

以上为项目中配置所有代码。
备注：
TimeUnit.SECONDS与TimeUnit.MILLISECONDS区别：
TimeUnit.SECONDS（5）线程等待五秒
TimeUnit.MILLISECONDS(5000)线程等待五秒.
两者的时间单位不一样。
内部都是Thread.sleep实现。