自定义注解+redis实现简单易用的分布式锁

分布式锁优化实践
最新推荐文章于 2025-08-05 10:10:06 发布
原创 最新推荐文章于 2025-08-05 10:10:06 发布 · 845 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#分布式锁

最近项目中有的模块功能涉及到并发，为了提高项目中分布式锁的易用性，在之前的一个思路基础上进行了迭代改进。
https://blog.youkuaiyun.com/yuruixin_china/article/details/79441260
这是之前写的一篇关于分布式锁的文章。
最近测试了一把之前的这个设计思路，发现有逻辑漏洞

如上图中，当finally代码块中释放锁的逻辑执行时，该处切入的方法实际还没有完全执行完成，还未提交事务。原因是事务的执行顺序是int的最大值，即最后执行。
尝试了将切面的执行顺序和事务的执行顺序进行配置，未能成功，看到有文章提到事务的织入方式与Aspectj的不同，所以执行顺序无法通过配置Order来控制

进一步考量后，其实我的需求就是在当前事务提交之后，执行我的释放锁操作
于是，再次百度觅之，无果。
遂，换上google，第一页就找到了解决方案。
还是谷歌大发好啊！！！
spring的事务模块，提供了一个TransactionSynchronizationManager类，代码如下：

public abstract class TransactionSynchronizationManager {
    private static final Log logger = LogFactory.getLog(TransactionSynchronizationManager.class);
    private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal("Transactional resources");
    private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = new NamedThreadLocal("Transaction synchronizations");
    private static final ThreadLocal<String> currentTransactionName = new NamedThreadLocal("Current transaction name");
    private static final ThreadLocal<Boolean> currentTransactionReadOnly = new NamedThreadLocal("Current transaction read-only status");
    private static final ThreadLocal<Integer> currentTransactionIsolationLevel = new NamedThreadLocal("Current transaction isolation level");
    private static final ThreadLocal<Boolean> actualTransactionActive = new NamedThreadLocal("Actual transaction active");

    public TransactionSynchronizationManager() {
    }

    public static Map<Object, Object> getResourceMap() {
        Map<Object, Object> map = (Map)resources.get();
        return map != null ? Collections.unmodifiableMap(map) : Collections.emptyMap();
    }

    public static boolean hasResource(Object key) {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Object value = doGetResource(actualKey);
        return value != null;
    }

    @Nullable
    public static Object getResource(Object key) {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Object value = doGetResource(actualKey);
        if (value != null && logger.isTraceEnabled()) {
            logger.trace("Retrieved value [" + value + "] for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
        }

        return value;
    }

    @Nullable
    private static Object doGetResource(Object actualKey) {
        Map<Object, Object> map = (Map)resources.get();
        if (map == null) {
            return null;
        } else {
            Object value = map.get(actualKey);
            if (value instanceof ResourceHolder && ((ResourceHolder)value).isVoid()) {
                map.remove(actualKey);
                if (map.isEmpty()) {
                    resources.remove();
                }

                value = null;
            }

            return value;
        }
    }

    public static void bindResource(Object key, Object value) throws IllegalStateException {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Assert.notNull(value, "Value must not be null");
        Map<Object, Object> map = (Map)resources.get();
        if (map == null) {
            map = new HashMap();
            resources.set(map);
        }

        Object oldValue = ((Map)map).put(actualKey, value);
        if (oldValue instanceof ResourceHolder && ((ResourceHolder)oldValue).isVoid()) {
            oldValue = null;
        }

        if (oldValue != null) {
            throw new IllegalStateException("Already value [" + oldValue + "] for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
        } else {
            if (logger.isTraceEnabled()) {
                logger.trace("Bound value [" + value + "] for key [" + actualKey + "] to thread [" + Thread.currentThread().getName() + "]");
            }

        }
    }

    public static Object unbindResource(Object key) throws IllegalStateException {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Object value = doUnbindResource(actualKey);
        if (value == null) {
            throw new IllegalStateException("No value for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
        } else {
            return value;
        }
    }

    @Nullable
    public static Object unbindResourceIfPossible(Object key) {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        return doUnbindResource(actualKey);
    }

    @Nullable
    private static Object doUnbindResource(Object actualKey) {
        Map<Object, Object> map = (Map)resources.get();
        if (map == null) {
            return null;
        } else {
            Object value = map.remove(actualKey);
            if (map.isEmpty()) {
                resources.remove();
            }

            if (value instanceof ResourceHolder && ((ResourceHolder)value).isVoid()) {
                value = null;
            }

            if (value != null && logger.isTraceEnabled()) {
                logger.trace("Removed value [" + value + "] for key [" + actualKey + "] from thread [" + Thread.currentThread().getName() + "]");
            }

            return value;
        }
    }

    public static boolean isSynchronizationActive() {
        return synchronizations.get() != null;
    }

    public static void initSynchronization() throws IllegalStateException {
        if (isSynchronizationActive()) {
            throw new IllegalStateException("Cannot activate transaction synchronization - already active");
        } else {
            logger.trace("Initializing transaction synchronization");
            synchronizations.set(new LinkedHashSet());
        }
    }

    public static void registerSynchronization(TransactionSynchronization synchronization) throws IllegalStateException {
        Assert.notNull(synchronization, "TransactionSynchronization must not be null");
        if (!isSynchronizationActive()) {
            throw new IllegalStateException("Transaction synchronization is not active");
        } else {
            ((Set)synchronizations.get()).add(synchronization);
        }
    }

    public static List<TransactionSynchronization> getSynchronizations() throws IllegalStateException {
        Set<TransactionSynchronization> synchs = (Set)synchronizations.get();
        if (synchs == null) {
            throw new IllegalStateException("Transaction synchronization is not active");
        } else if (synchs.isEmpty()) {
            return Collections.emptyList();
        } else {
            List<TransactionSynchronization> sortedSynchs = new ArrayList(synchs);
            AnnotationAwareOrderComparator.sort(sortedSynchs);
            return Collections.unmodifiableList(sortedSynchs);
        }
    }

    public static void clearSynchronization() throws IllegalStateException {
        if (!isSynchronizationActive()) {
            throw new IllegalStateException("Cannot deactivate transaction synchronization - not active");
        } else {
            logger.trace("Clearing transaction synchronization");
            synchronizations.remove();
        }
    }

    public static void setCurrentTransactionName(@Nullable String name) {
        currentTransactionName.set(name);
    }

    @Nullable
    public static String getCurrentTransactionName() {
        return (String)currentTransactionName.get();
    }

    public static void setCurrentTransactionReadOnly(boolean readOnly) {
        currentTransactionReadOnly.set(readOnly ? Boolean.TRUE : null);
    }

    public static boolean isCurrentTransactionReadOnly() {
        return currentTransactionReadOnly.get() != null;
    }

    public static void setCurrentTransactionIsolationLevel(@Nullable Integer isolationLevel) {
        currentTransactionIsolationLevel.set(isolationLevel);
    }

    @Nullable
    public static Integer getCurrentTransactionIsolationLevel() {
        return (Integer)currentTransactionIsolationLevel.get();
    }

    public static void setActualTransactionActive(boolean active) {
        actualTransactionActive.set(active ? Boolean.TRUE : null);
    }

    public static boolean isActualTransactionActive() {
        return actualTransactionActive.get() != null;
    }

    public static void clear() {
        synchronizations.remove();
        currentTransactionName.remove();
        currentTransactionReadOnly.remove();
        currentTransactionIsolationLevel.remove();
        actualTransactionActive.remove();
    }
}

其中有两个方法可以解决之前设计漏洞：
isActualTransactionActive
registerSynchronization

具体应用如下（优化后的代码）：

Lock注解

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Lock {

    /**
     * 分布式锁的key前缀
     */
    LockKeyPrefixEnum lockKeyPrefix();

    String description();

    /**
     * 等待超时单位：秒
     */
    int timeOut() default 5;

    /**
     * 过期时长单位：秒
     */
    int expireTime() default 3;
}

锁的key前缀枚举LockKeyPrefixEnum


/**
 * @ClassName: LockKeyPrefixEnum
 * @Description: lockkey前缀管理
 * @Auther: RuiXin Yu
 * @Date: 2018/12/26 10:53
 */
public enum LockKeyPrefixEnum {

    A_B_C("a_b_c_");

    private String info;

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    LockKeyPrefixEnum(String info) {
        this.info = info;
    }
}

切面核心处理类LockService

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.lang.reflect.Method;

/**
 * @ClassName: LockService
 * @Description: 分布式锁切面服务
 *
 * 使用前必读
 * 使用该锁时，应注意以下几点：
 * 1. 为了将加锁粒度控制到最小，建议在使用时须传一个lockKeyPrefix作为额外加锁条件（如id）
 * 2. 确实不需要额外控制粒度的，显式将lockKeyPrefix置为空串
 * 3. description同为必填项，作为获取锁失败时，日志打印使用，为该方法的行为描述
 * 4. timeOut等待超时时间,默认为5秒
 * 5. expireTime锁的有效时长（即过期时间），默认为3秒
 * 6.使用该锁，请确认使用场景正确、粒度控制适度、参数传递正确，并进行并发测试来确认锁是否达到期望效果
 *
 * @Auther: RuiXin Yu
 * @Date: 2018/12/26 9:11
 */
@Component
@Aspect
@Order
public class LockService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    protected Logger logger = LoggerFactory.getLogger(this.getClass());

    @Pointcut("@annotation(com.choice.cloud.smp.basic.lock.Lock)")
    public void lockPointcut() {

    }

    @Around("lockPointcut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {

        Lock lock = getMethodAnnotation(point);
        String lockKeySuffix = getLockKeySuffix(point);

        // 获得锁对象实例
        String lockKey = lock.lockKeyPrefix().getInfo() + lockKeySuffix;
        RedisLock redisLock = new RedisLock(stringRedisTemplate, lockKey, String.valueOf(lock.expireTime()), lock.timeOut()*1000*100);
        try {
            if (redisLock.tryLock()) {
                return point.proceed(point.getArgs());
            } else {
                logger.error("{}:获取redis锁失败,锁的key是 = {}", lock.description(), lockKey);
                throw new CustomException(lock.description()+"获取锁失败");
            }
        } finally {
            if(TransactionSynchronizationManager.isActualTransactionActive()){
                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                    @Override
                    public void afterCommit() {
                        redisLock.unlock();
                        super.afterCommit();
                    }
                });
            }else{
                redisLock.unlock();
            }
        }
    }

    /**
     * 获取分布式锁后缀
     * @param point
     * @return
     */
    private String getLockKeySuffix(ProceedingJoinPoint point) {
        Object[] methodParam = point.getArgs();
        String lockKeySuffix;
        try {
            lockKeySuffix = (String) methodParam[0];
        }catch (ClassCastException e){
            logger.error("加锁方法参数不合法:{}", methodParam[0]);
            throw new CustomException("加锁方法参数不合法");
        }
        return lockKeySuffix;
    }


    /**
     * 获取分布式锁注解中的参数
     * @param joinPoint
     * @return
     */
    private Lock getMethodAnnotation(JoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        return method.getAnnotation(Lock.class);
    }
}

改进后的finally代码块中，不再直接释放锁，而是将释放锁的操作注册到事务提交后执行
若该切面不在事务中运行，则直接释放锁。

2018年就要结束了
温故而知新
做一个有追求的技术人

Redisson之——使用Redisson通过自定义注解实现分布式锁，使用Spring AOP简化分布式锁
2401_84009929的博客
04-18 761
这份面试题几乎包含了他在一年内遇到的所有面试题以及答案，甚至包括面试中的细节对话以及语录，可谓是细节到极致，甚至简历优化和怎么投简历更容易得到面试机会也包括在内！也包括教你怎么去获得一些大厂，比如阿里，腾讯的内推名额！某位名人说过成功是靠99%的汗水和1%的机遇得到的，而你想获得那1%的机遇你首先就得付出99%的汗水！你只有朝着你的目标一步一步坚持不懈的走下去你才能有机会获得成功！成功只会留给那些有准备的人！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》
简单注解实现集群同步锁（spring+redis+注解）
08-31
通过Spring的AOP（面向切面编程）和Redis的分布式锁机制，文章提出的解决方案提供了一种简单易用的方式，在集群环境中实现方法级别的同步锁。这有助于防止并发访问同一资源时引发的数据不一致问题，同时也提供了锁...
自定义注解 redis分布式锁
zhaohan___的博客
05-23 505
文章目录1.前言2.设计3.实现3.1 自定义注解3.2切面实现4.使用 1.前言 因为系统使用了微服务，有部分接口和代码需要保持同一时间节点只能被同一个线程执行，所以需要增加分布式锁，如果简单的使用redisTemplate的写起来比较麻烦，所以打算自定义注解使用切面的方式进行复用。 2.设计 如果要实现上述的想法需要考虑如下几个问题： 锁竞争，抢锁的时候尝试竞争三次 异常处理，当程序出现异常需要及时抛出锁 自旋锁，有些程序不可以失败必须抢锁执行 3.实现 3.1 自定义注解 name：锁名称，根据
自定义注解实现
weixin_43975276的博客
06-07 1728
实现自定义注解其实很简单，格式基本都差不多。也就参数可能变一变。
一个注解轻松搞定Redis分布式锁
最新发布
路漫漫其修远兮，吾将上下而求索
08-05 433
就像很多底层sdk，都是有接口调用的方法来实现核心功能，然后再加个注解让使用更加简便。我们可以抽出一个DistributeLock工具类，把锁的模板写在方法里，调用的时候只需要指定key，把锁内的代码块用。来想一想场景，我们的分布式锁很多时候都是加在最外层，也就是controller上，或者是service某个方法上。很多时候我们的锁都是针对方法的，要锁同一处地方，调用同一个方法就好了，这样前缀可以直接默认根据。约定大于配置的思想，我们的大多数参数都是可以默认的。，既然是模板，那为何不把他抽出来呢？
AOP+自定义注解+Redis实现分布式锁
小学生波波
10-29 3300
AOP+自定义注解+Redis实现分布式锁
分布式锁？一个注解就搞定了
weixin_53294082的博客
10-30 1350
在开发过程中，分布式系统中的数据一致性和并发问题尤为重要，常需添加锁。Redis 作为高性能的键值存储，常用于实现分布式锁。通过 Redisson 库，我们可以在 Java 应用中轻松实现分布式锁。接下来，我将演示如何通过自定义注解来实现这一功能，使我们在业务逻辑中以更简洁的方式使用分布式锁。这样可以减少代码重复，提高代码可读性，同时确保锁的使用符合业务需求。
SpringBoot+nacos+websocket+redis+mysql+mybatis-plus微服务项目实战
01-11
开发者可以利用SpringBoot快速搭建服务，通过Nacos实现服务治理，使用WebSocket进行实时通信，借助Redis缓存数据并提高响应速度，同时利用MySQL和Oracle存储业务数据。Swagger2帮助我们清晰地定义和展示API，而...
Spring boot+redis实现消息发布与订阅的代码
12-14
在本文中，我们将深入探讨如何使用Spring Boot和Redis来实现消息发布与订阅功能。Spring Boot以其简化Spring...这个框架不仅提供了简单易用的API，还具有良好的可扩展性，适用于各种复杂的分布式系统中的消息传递需求。
销售系统项目，spring+spring mvc+mybatis+dubbo+kafka+redis+maven.zip
08-20
【标题】"销售系统项目，spring+spring mvc+mybatis+dubbo+kafka+redis+maven.zip" 提供了一个综合的IT解决方案，涉及到的技术栈主要包括Spring、Spring MVC、MyBatis、Dubbo、Kafka、Redis以及Maven。这个项目采用...
SpringCache+Redis实现高可用缓存解决方案.docx
10-26
Spring Boot框架自带的`ConcurrentMapCacheManager`虽然简单易用，但对于分布式环境下的应用来说，其局限性较为明显，无法满足高可用性的需求。因此，本文将详细介绍如何利用Spring Cache与Redis结合，构建一套高效...
AOP+自定义注解实现Redis分布式锁
阿鹏的博客
01-15 740
一、场景 定时任务，有过项目经历的开发者估计都不陌生，是实现一些定时执行重复操作需求的常见解决方案。 在单机的情况下，定时任务当然是越用越爽，简单粗暴直接cron表达式走起就行了，但是在微服务的场景下，要考虑多实例的问题。比如一个定时任务，由于被部署了在多台机器上（或同一台不同端口），这时候，可能会出现定时任务在同一时间被多次执行的问题。 为了保证在同一周期内，只有一个定时任务在执行，其他的不执行，可以采用redis分布式锁、数据库锁、zookeeper锁等方式去实现。 本文采用redis分布式锁的思路去实
自定义注解实现分布式锁
qq_37205211的博客
12-25 1802
自定义注解实现分布式锁中间件
自定义注解实现分布式锁 @DistributedLock
yyh695809001的博客
10-16 439
Slf4j@Aspect@Resource//校验表达式try {} else {throw new RuntimeException("操作进行中");/*** 解析key* @return*/if (!return key;i++) {try {throw new IllegalArgumentException("SPEL表达式解析结果为null");
【实战教程】使用自定义注解实现分布式锁
自律使我自由
03-13 1888
使用自定义注解实现分布式锁
Redis分布式锁，使用aop +自定义注解 实现
如果有一天我能够拥有一个大果园，我愿放下所有追求做个农夫去种田
06-21 1360
Redis分布式锁实现1.Redis分布式锁理论2.Redis整合 封装服务类3.自定义注解4.Aop实现注解环绕通知、获取注解参数、加锁解锁5.ThreadLocal实现可重入锁 1.Redis分布式锁理论 Redis有一系列的命令，特点是以NX结尾，NX是Not eXists的缩写，如SETNX命令就应该理解为：SET if Not eXists。 设置成功，返回 1 。 设置失败，返回 0 由于Redis为单进程单线程模式，采用队列模式将并发访问变成串行访问，命令是一条一条执行的所以可以利用setNx
使用自定义注解实现Redis分布式锁
热门推荐
一恍过去
06-29 2万+
使用自定义注解实现Redis分布式锁
自定义注解+Spel实现分布式锁
qq_37272886的博客
09-11 283
文章地址：自定义注解+Spel实现分布式锁_小熙的博客-优快云博客 方便以后好找
自定义分布式锁（基于redis的开发）
weixin_44589578的博客
08-15 295
自定义分布式锁redis
Spring AOP实现多方案分布式锁支持Redis和Zookeeper
同时，方案支持扩展性，意味着开发者可以自定义锁的实现，或者将现有的实现与其他锁机制进行结合，以适应更加复杂的应用场景。 5. 服务器应用与分布式服务框架 本资源所介绍的分布式锁技术，对于服务器应用和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值