基于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实现。

• 点赞
• 收藏
• 分享
• 文章举报