---

前言

通常服务端存在定时器业务时，如果分布式部署，多台同时执行会出现重复的数据，为了避免这种情况，可采用分布式锁。本章节讲解分布式锁RedissonLock以及锁的业务级的应用，内容包括两部分：

1. RedissonLock源代码分析
2. 锁业务应用
   • 接口方法@注解方式 注入锁
   • 代码行加锁

---

一、RedissonLock源代码分析

1.1 尝试加锁

主线：org.redisson.RedissonLock#tryLock(long waitTime, long leaseTime, TimeUnit unit)

public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {long time = unit.toMillis(waitTime);//取得最大等待时间long current = System.currentTimeMillis();//取得当前线程id（判断是否可重入锁的关键）long threadId = Thread.currentThread().getId();//1.尝试申请锁，返回还剩余的锁过期时间Long ttl = this.tryAcquire(waitTime, leaseTime, unit, threadId);if (ttl == null) {return true;//2.ttl 为空，申请锁成功} else {//3.最大等待时间time <= 申请锁的耗时，则申请锁失败time = time - (System.currentTimeMillis() - current);if (time <= 0L) {this.acquireFailed(waitTime, unit, threadId);return false;} else {current = System.currentTimeMillis();/*** 4.订阅锁释放事件，并通过await方法阻塞等待锁释放：* 基于信息量，当锁被其它资源占用时，当前线程通过 Redis 的 channel 订阅锁的释放事件，* 一旦锁释放会发消息通知待等待的线程进行竞争*/RFuture<RedissonLockEntry> subscribeFuture = this.subscribe(threadId);//await 方法内部是用CountDownLatch来实现阻塞，//获取subscribe异步执行的结果(应用Netty Future)if (!subscribeFuture.await(time, TimeUnit.MILLISECONDS)) {//await(...)返回false，等待时间已经超出获取锁最大等待时间，//取消订阅并返回获取锁失败if (!subscribeFuture.cancel(false)) {subscribeFuture.onComplete((res, e) -> {if (e == null) {this.unsubscribe(subscribeFuture, threadId);}});}this.acquireFailed(waitTime, unit, threadId);return false;} else {//await(...)返回true，进入循环尝试获取锁try {time -= System.currentTimeMillis() - current;if (time <= 0L) {this.acquireFailed(waitTime, unit, threadId);boolean var20 = false;return var20;} else {boolean var16;//5.收到锁释放的信号后，在最大等待时间之内，自旋尝试获取锁do {long currentTime = System.currentTimeMillis();// 再次尝试申请锁ttl = this.tryAcquire(waitTime, leaseTime, unit, threadId);if (ttl == null) {var16 = true;return var16;//成功获取锁则直接返回true结束循环}time -= System.currentTimeMillis() - currentTime;if (time <= 0L) {this.acquireFailed(waitTime, unit, threadId);var16 = false;return var16;}currentTime = System.currentTimeMillis();//6.阻塞等待锁(通过信号量(共享锁)阻塞,等待解锁消息)if (ttl >= 0L && ttl < time) {// 在ttl时间内尝试获取信号量((RedissonLockEntry)subscribeFuture.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);} else {// 在time时间内尝试获取信号量((RedissonLockEntry)subscribeFuture.getNow()).getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);}time -= System.currentTimeMillis() - currentTime;} while(time > 0L);this.acquireFailed(waitTime, unit, threadId);var16 = false;return var16;}} finally {//7.无论是否获得锁,都要取消订阅解锁消息this.unsubscribe(subscribeFuture, threadId);}}}}}

订阅：RFuture subscribe(String entryName, String channelName)
‌发布订阅: 基于信号量的异步订阅机制，订阅指定的Redis频道channel，返回异步Future对象

abstract class PublishSubscribe<E extends PubSubEntry<E>> {public RFuture<E> subscribe(String entryName, String channelName) {AsyncSemaphore semaphore = this.service.getSemaphore(new ChannelName(channelName));RPromise<E> newPromise = new RedissonPromise();semaphore.acquire(() -> {if (!newPromise.setUncancellable()) {semaphore.release();} else {......//创建RedisPubSubListenerRedisPubSubListener<Object> listener = this.createListener(channelName,value);//订阅通道channelName、信号semaphore，绑定RedisPubSubListenerthis.service.subscribe(LongCodec.INSTANCE, channelName, semaphore, new RedisPubSubListener[]{listener});}});return newPromise;}......//创建监听器，用于监听指定频道的消息和订阅状态private RedisPubSubListener<Object> createListener(final String channelName, final E value) {RedisPubSubListener<Object> listener = new BaseRedisPubSubListener() {public void onMessage(CharSequence channel, Object message) {//接收到指定频道的消息时,开始处理消息if (channelName.equals(channel.toString())) {PublishSubscribe.this.onMessage(value, (Long)message);}}//当订阅成功时，标记 value 的 Promise 为成功。public boolean onStatus(PubSubType type, CharSequence channel) {if (!channelName.equals(channel.toString())) {return false;} else if (type == PubSubType.SUBSCRIBE) {value.getPromise().trySuccess(value);return true;} else {return false;}}};return listener;}
}

子线：tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId)

private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, 
TimeUnit unit, long threadId) {if (leaseTime != -1L) {return this.tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);} else {//tryLockInnerAsync-申请锁,申请锁并返回RFutureRFuture<Long> ttlRemainingFuture = this.tryLockInnerAsync(waitTime, this.internalLockLeaseTime, TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);ttlRemainingFuture.onComplete((ttlRemaining, e) -> {if (e == null) {if (ttlRemaining == null) {this.scheduleExpirationRenewal(threadId);}}});return ttlRemainingFuture;}}

tryLockInnerAsync-尝试异步加锁

<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, 
RedisStrictCommand<T> command) {internalLockLeaseTime = unit.toMillis(leaseTime);/*** 通过 EVAL 命令执行 Lua 脚本获取锁，保证了原子性*/return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,// 1.如果缓存中的key不存在，则执行 hset 命令(hset key UUID+threadId 1),然后通过 pexpire 命令设置锁的过期时间(即锁的租约时间)// 返回空值 nil ，表示获取锁成功"if (redis.call('exists', KEYS[1]) == 0) then " +"redis.call('hset', KEYS[1], ARGV[2], 1); " +"redis.call('pexpire', KEYS[1], ARGV[1]); " +"return nil; " +"end; " +// 如果key已经存在，并且value也匹配，表示是当前线程持有的锁，则执行 hincrby 命令，重入次数加1，并且设置失效时间"if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +"redis.call('hincrby', KEYS[1], ARGV[2], 1); " +"redis.call('pexpire', KEYS[1], ARGV[1]); " +"return nil; " +"end; " +//如果key已经存在，但是value不匹配，说明锁已经被其他线程持有，通过 pttl 命令获取锁的剩余存活时间并返回，至此获取锁失败"return redis.call('pttl', KEYS[1]);",//这三个参数分别对应KEYS[1]，ARGV[1]和ARGV[2]Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
}
参数说明：KEYS[1]就是Collections.singletonList(getName())，表示分布式锁的keyARGV[1]就是internalLockLeaseTime，即锁的租约时间（持有锁的有效时间），默认30sARGV[2]就是getLockName(threadId)，是获取锁时set的唯一值 value，即UUID+threadId

scheduleExpirationRenewal-redisson看门狗机制

• 定期续租 Redisson 分布式锁的过期时间，防止锁因超时而被提前释放。
• 创建一个定时任务，每隔internalLockLeaseTime / 3 毫秒执行一次；定时任务中调用 renewExpirationAsync()，异步续期锁，并递归继续下一次续期。

private void renewExpiration() {ExpirationEntry ee = (ExpirationEntry)EXPIRATION_RENEWAL_MAP.get(this.getEntryName());if (ee != null) {Timeout task = this.commandExecutor.getConnectionManager().newTimeout(new TimerTask() {public void run(Timeout timeout) throws Exception {ExpirationEntry ent = (ExpirationEntry)RedissonLock.EXPIRATION_RENEWAL_MAP.get(RedissonLock.this.getEntryName());if (ent != null) {Long threadId = ent.getFirstThreadId();if (threadId != null) {// 更新锁过期时间（lua脚本）RFuture<Boolean> future = RedissonLock.this.renewExpirationAsync(threadId);future.onComplete((res, e) -> {if (e != null) {RedissonLock.log.error("Can't update lock " + RedissonLock.this.getName() + " expiration", e);RedissonLock.EXPIRATION_RENEWAL_MAP.remove(RedissonLock.this.getEntryName());} else {if (res) {//递归调用 如果10秒后依然没有解锁，继续更新锁过期时间RedissonLock.this.renewExpiration();}}});}}}}, this.internalLockLeaseTime / 3L, TimeUnit.MILLISECONDS);ee.setTimeout(task);}}............/*异步续订分布式锁的过期时间，具体如下：使用 Lua 脚本保证操作的原子性；检查当前线程是否持有锁（通过 hexists 判断）；如果持有，则通过 pexpire 延长锁的过期时间；返回值表示是否成功续订（1 成功，0 失败）*/protected RFuture<Boolean> renewExpirationAsync(long threadId) {return this.evalWriteAsync(this.getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN, "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +"redis.call('pexpire', KEYS[1], ARGV[1]); " +"return 1; " +"end; " +"return 0;", Collections.singletonList(this.getName()), this.internalLockLeaseTime, this.getLockName(threadId));}............
参数：
this.internalLockLeaseTime = commandExecutor.getConnectionManager()
.getCfg().getLockWatchdogTimeout();//默认30秒

2.2 解锁

org.redisson.RedissonLock#unlock()

protected RFuture<Boolean> unlockInnerAsync(long threadId) {/*** 通过 EVAL 命令执行 Lua 脚本获取锁，保证了原子性*/return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,//如果分布式锁存在，但是value不匹配，表示锁已经被其他线程占用,//当前客户端线程没有持有锁，不能主动解锁"if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +"return nil;" +"end; " +//如果value匹配，将value减1，主要用在重入锁"local counter=redis.call('hincrby',KEYS[1], ARGV[3],-1);" +//重入次数减1后的值如果大于0，表示分布式锁有重入过，//那么只能更新失效时间，还不能删除"if (counter > 0) then " +"redis.call('pexpire', KEYS[1], ARGV[2]); " +"return 0; " +"else " +//重入次数减1后的值如果为0，这时就可以删除这个KEY，//并发布解锁消息，返回1"redis.call('del', KEYS[1]); " +"redis.call('publish', KEYS[2], ARGV[1]); " +"return 1; "+"end; " +"return nil;",Arrays.<Object>asList(getName(), getChannelName()), LockPubSub.UNLOCK_MESSAGE, internalLockLeaseTime, getLockName(threadId));
}

参数：
KEYS1：需要加锁的key，这里需要是字符串类型。
KEYS2：redis消息的ChannelName,一个分布式锁对应唯一的一个 channelName:“redisson_lock__channel__{” + getName() + “}”
ARGV1：redis消息体，这里只需要一个字节的标记就可以，主要标记redis的key已经解锁，再结合redis的Subscribe，能唤醒其他订阅解锁消息的客户端线程申请锁。
ARGV2：锁的超时时间，防止死锁
ARGV3 ：锁的唯一标识，也就是刚才介绍的 id（UUID.randomUUID()） + “:” + threadId

删除过期信息

void cancelExpirationRenewal() {Timeout task = expirationRenewalMap.remove(getEntryName());if (task != null) {task.cancel();}
}

二、锁业务应用

1.服务层方法@注解方式 注入锁

1.1 定义DistributedLock @注解类

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DistributedLock {String key();int timeout() default 10; // 默认超时时间10秒int maxExecuteTime() default 30;TimeUnit timeUnit() default TimeUnit.SECONDS;
}

1.2 定义DistributedLockAspect 切片类

  拦截带有 @DistributedLock 注解的方法。

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.context.expression.MethodBasedEvaluationContext;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;@Aspect
@Component
@Slf4j
public class DistributedLockAspect {@Resourceprivate RedissonClient redissonClient;private final ExpressionParser parser = new SpelExpressionParser();private final DefaultParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();@Around("@annotation(distributedLock)")public Object around(ProceedingJoinPoint joinPoint, DistributedLock distributedLock) throws Throwable {String methodName = joinPoint.getSignature().getName();String dynamicKey = parseSpEL(joinPoint, distributedLock.key());long timeout = distributedLock.timeout();long maxExecuteTime = distributedLock.maxExecuteTime();TimeUnit timeUnit = distributedLock.timeUnit();//解析keylog.info("[锁切面] 方法 {} 尝试获取锁，key={}, timeout={}{}", methodName, dynamicKey, timeout, timeUnit.name());RLock lock = redissonClient.getLock(dynamicKey);boolean isLocked = false;try {// 尝试获取锁isLocked = lock.tryLock(timeout, maxExecuteTime, timeUnit);if (!isLocked) {log.error("[Redisson锁] 获取锁失败，key={}", dynamicKey);throw new RuntimeException("系统繁忙，请重试");}log.info("[Redisson锁] 锁获取成功，key={}", dynamicKey);return joinPoint.proceed(); // 执行业务方法} finally {if (isLocked && lock.isHeldByCurrentThread()) {lock.unlock();log.info("[Redisson锁] 锁已释放，key={}", dynamicKey);}}}/*** 解析 SpEL 表达式*/private String parseSpEL(ProceedingJoinPoint joinPoint, String spEL) {if (!spEL.contains("#")) {return spEL;}Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();Object[] args = joinPoint.getArgs();// 创建 SpEL 上下文EvaluationContext context = new MethodBasedEvaluationContext(null, method, args, parameterNameDiscoverer);// 解析表达式Expression expression = parser.parseExpression(spEL);return expression.getValue(context, String.class);}
}

1.3 尝试获取锁代码片断

@Around("@annotation(distributedLock)")
public Object around(ProceedingJoinPoint joinPoint, 
DistributedLock distributedLock) {......String dynamicKey = parseSpEL(joinPoint, distributedLock.key());......RLock lock = redissonClient.getLock(dynamicKey);......// 尝试获取锁isLocked = lock.tryLock(timeout, maxExecuteTime, timeUnit);if (!isLocked) {log.error("[Redisson锁] 获取锁失败，key={}", dynamicKey);}else{log.info("[Redisson锁] 锁获取成功，key={}", dynamicKey);return joinPoint.proceed(); // 执行业务方法}
}............package org.redisson;
public class Redisson implements RedissonClient {public RLock getLock(String name) {return new RedissonLock(this.connectionManager.getCommandExecutor(), name);}
}

1.4 释放锁代码片断

 @Around("@annotation(distributedLock)")public Object around(ProceedingJoinPoint joinPoint, DistributedLock distributedLock) { ............finally {if (isLocked && lock.isHeldByCurrentThread()) {lock.unlock();log.info("[Redisson锁] 锁已释放，key={}", dynamicKey);}}
}

1.5 服务层注入锁@注解

锁定方法、业务，同一时刻点  或 某一时段内 不可重复执行。

//订单job服务实现类OrderJobServiceImpl  
@Service
@RequiredArgsConstructor
@Slf4j
@RefreshScope
public class OrderJobServiceImpl  {/**** [描述]: 执行订单创建任务* 具备分布式锁防止并发执行，锁超时timeout为30秒* @date 2025/6/16 14:09* @param id* @param updateNextExecuteDate* @param executeAtDate*/@Override@DistributedLock(key = "#id", timeout = 30)public void execute(Long id) { ............//某一时刻点执行订单创建任务............
}

2.代码行加锁

2.1 pom.xml文件引入redisson、redis

   <dependency><groupId>org.redisson</groupId><artifactId>redisson</artifactId><version>3.14.1</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-redis</artifactId></dependency>

2.2 配置RedissonProperties属性类

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;@Data
@Configuration
public class RedissonProperties {@Value("${spring.redis.host:}")private String redisHost;@Value("${spring.redis.port:}")private String redisPort;@Value("${spring.redis.sentinel.nodes:}")private String redisSentinelNodes;@Value("${spring.redis.cluster.nodes:}")private String redisClusterNodes;@Value("${spring.redis.sentinel.master:}")private String redisMasterName;@Value("${spring.redis.password:}")private String password;private String springRedis = "spring.redis";private int timeout = 10000;private int connectionPoolSize = 64;private int connectionMinimumIdleSize = 10;private int slaveConnectionPoolSize = 250;private int masterConnectionPoolSize = 250;public String[] getRedisSentinelNodes() {return redisSentinelNodes.contains(springRedis) ? null : redisSentinelNodes.split(",");}public String[] getRedisClusterNodes() {return redisClusterNodes.contains(springRedis) ? null : redisClusterNodes.split(",");}
}

2.3 Redisson装配类

• 初始化RedissonClient
• 装配锁Redisson实现类RedissonDistributedLockerServiceImpl，并将实例注入到RedissLockUtil中。

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;/*** @desc 装配类*/
@Configuration
@ConditionalOnClass(Config.class)
public class RedissonAutoConfiguration {@Resourceprivate RedissonProperties redissonProperties;private static final String REDIS_PROTOCOL_PREFIX = "redis://";/*** @version 哨兵模式自动装配*/private Config redissonMasterSentinel() {String[] nodes = redissonProperties.getRedisSentinelNodes();if (null == nodes || nodes.length == 0 || "".equals(nodes[0])) {return null;}List<String> clusterNodes = new ArrayList<>();for (String node : nodes) {clusterNodes.add(REDIS_PROTOCOL_PREFIX + node);}Config config = new Config();config.useSentinelServers().addSentinelAddress(clusterNodes.toArray(new String[0])).setMasterName(redissonProperties.getRedisMasterName()).setTimeout(redissonProperties.getTimeout()).setPassword(redissonProperties.getPassword()).setMasterConnectionPoolSize(redissonProperties.getMasterConnectionPoolSize()).setSlaveConnectionPoolSize(redissonProperties.getSlaveConnectionPoolSize());return config;}/*** @version 集群模式自动装配*/private Config redissonClusterSentinel() {String[] nodes = redissonProperties.getRedisClusterNodes();if (null == nodes || nodes.length == 0 || "".equals(nodes[0])) {return null;}List<String> clusterNodes = new ArrayList<>();for (String node : nodes) {clusterNodes.add(REDIS_PROTOCOL_PREFIX + node);}Config config = new Config();config.useClusterServers().setScanInterval(1000).setTimeout(redissonProperties.getTimeout()).setPassword(redissonProperties.getPassword()).addNodeAddress(clusterNodes.toArray(new String[0])).setMasterConnectionPoolSize(redissonProperties.getMasterConnectionPoolSize()).setSlaveConnectionPoolSize(redissonProperties.getSlaveConnectionPoolSize());return config;}/*** 单机模式自动装配* @return*/private Config redissonAddressSingle() {Config config = new Config();if (null == redissonProperties.getRedisHost() || "".equals(redissonProperties.getRedisHost())) {return null;}config.useSingleServer().setAddress(REDIS_PROTOCOL_PREFIX+redissonProperties.getRedisHost() + ":" + redissonProperties.getRedisPort()).setTimeout(redissonProperties.getTimeout()).setPassword(redissonProperties.getPassword()).setConnectionPoolSize(redissonProperties.getConnectionPoolSize()).setConnectionMinimumIdleSize(redissonProperties.getConnectionMinimumIdleSize());return config;}/*** 初始化RedissonClient* 采用实例化顺序：集群模式 > 哨兵模式 > 单机模式*/@BeanRedissonClient redissonSingle() {Config config = redissonClusterSentinel();if (null == config) {config = redissonMasterSentinel();if (null == config) {config = redissonAddressSingle();}}if (null != config) {return Redisson.create(config);}return null;}/*** @version 装配RedissonDistributedLockerServiceImpl类，并将实例注入到RedissLockUtil*/@BeanDistributedLockerService distributedLocker(RedissonClient redissonClient) {RedissonDistributedLockerServiceImpl locker = new RedissonDistributedLockerServiceImpl();locker.setRedissonClient(redissonClient);RedissLockUtil.setLocker(locker);return locker;}
}

2.4 Redisson实现类和工具类

实现类RedissonDistributedLockerServiceImpl

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
/*** @version Redisson实现类*/@Service
public class RedissonDistributedLockerServiceImpl 
implements DistributedLockerService {private RedissonClient redissonClient;public void setRedissonClient(RedissonClient redissonClient) {this.redissonClient = redissonClient;}private static final String LOCK = "redisson_lock_";@Overridepublic RLock lock(String lockKey) {RLock lock = redissonClient.getLock(LOCK + lockKey);lock.lock();return lock;}@Overridepublic RLock lock(String lockKey, int leaseTime) {RLock lock = redissonClient.getLock(LOCK + lockKey);lock.lock(leaseTime, TimeUnit.SECONDS);return lock;}@Overridepublic RLock lock(String lockKey, TimeUnit unit, int timeout) {RLock lock = redissonClient.getLock(LOCK + lockKey);lock.lock(timeout, unit);return lock;}@Overridepublic boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {RLock lock = redissonClient.getLock(LOCK + lockKey);try {return lock.tryLock(waitTime, leaseTime, unit);} catch (InterruptedException e) {Thread.currentThread().interrupt();return false;}}@Overridepublic boolean isLocked(String lockKey) {RLock lock = redissonClient.getLock(LOCK + lockKey);return lock.isLocked();}@Overridepublic void unlock(String lockKey) {RLock lock = redissonClient.getLock(LOCK + lockKey);if (null != lock) {lock.unlock();}}@Overridepublic void unlock(RLock lock) {lock.unlock();}
}

2.5 Redisson工具类RedissLockUtil

import org.redisson.api.RLock;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;/*** @desc 工具类*/
@Component
public class RedissLockUtil {private static DistributedLockerService distributedLockerService;public static void setLocker(DistributedLockerService locker) {distributedLockerService = locker;}/*** 加锁* @param lockKey* @return*/public static RLock lock(String lockKey) {return distributedLockerService.lock(lockKey);}/*** 释放锁* @param lockKey*/public static void unlock(String lockKey) {distributedLockerService.unlock(lockKey);}/*** 释放锁* @param lock*/public static void unlock(RLock lock) {distributedLockerService.unlock(lock);}/*** 带超时的锁* @param lockKey* @param timeout 超时时间   单位：秒*/public static RLock lock(String lockKey, int timeout) {return distributedLockerService.lock(lockKey, timeout);}/*** 带超时的锁* @param lockKey* @param unit    时间单位* @param timeout 超时时间*/public static RLock lock(String lockKey, TimeUnit unit, int timeout) {return distributedLockerService.lock(lockKey, unit, timeout);}/*** 尝试获取锁* @param lockKey* @param waitTime  最多等待时间* @param leaseTime 上锁后自动释放锁时间* @return*/public static boolean tryLock(String lockKey, int waitTime, int leaseTime) {return distributedLockerService.tryLock(lockKey, TimeUnit.SECONDS, waitTime, leaseTime);}public static boolean isLocked(String lockKey) {return distributedLockerService.isLocked(lockKey);}/*** 尝试获取锁* @param lockKey* @param unit      时间单位* @param waitTime  最多等待时间* @param leaseTime 上锁后自动释放锁时间* @return*/public static boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {return distributedLockerService.tryLock(lockKey, unit, waitTime, leaseTime);}}

2.6 方法体内使用锁

方法体内使用锁，锁定某段区间代码 间的业务。例如下述业务：挂起订单

   @Transactional(rollbackFor = Exception.class)public void hangUpOrder(String orderId) {Order order = orderMapper.findByOrderId(orderId);.......try {//加锁RedissLockUtil.lock(orderRole.getOrderUuid());Date time = new Date();if ("启用".equals(order.getOrderHangUpStatus())) {// 当前是非挂起状态，进行挂起操作............}} catch (Exception e) {log.error("挂起操作有误：{}", e.getMessage(), e);} finally {//释放锁RedissLockUtil.unlock(orderRole.getOrderUuid());}}

场景一：使用tryLock获取Redis锁。
调用tryLock方法来尝试获取锁。如果成功获得锁，则在持有锁时执行try块中的代码。如果无法获取锁，则执行else块中的代码。

RLock lock = redisson.getLock("myLock");
//lock.tryLock(10, TimeUnit.SECONDS);等待10秒钟，未指定leaseTime参数，
开启看门狗（watchdog）机制自动续约
//lock.tryLock(1L, 10L, TimeUnit.SECONDS);等待1秒钟，指定leaseTime参数10秒(锁从持有到自动释放的时长),watchdog机制不会自动续约
if (lock.tryLock()) {try {// Do some work while holding the lock} finally {lock.unlock();}
} else {// Failed to acquire the lock
}

场景二：使用lock获取Redis锁。
调用lock方法来获取锁。如果不能立即获得锁，代码将阻塞，直到锁可用为止。获取锁后，将执行try块中的代码，同时持有锁。最后，在Finally块中释放锁。

RLock lock = redisson.getLock("myLock");
long leaseTime = 10L;
//指定leaseTime参数10秒(锁从持有到自动释放的时长)
//lock.lock(leaseTime, TimeUnit.SECONDS);
lock.lock();
try {// Do some work while holding the lock
} finally {lock.unlock();
}

---