redis分布式锁以及自定义注解

最新推荐文章于 2024-08-13 14:41:03 发布
最新推荐文章于 2024-08-13 14:41:03 发布
阅读量694 收藏 2
点赞数
分类专栏： redis锁 文章标签： redis 分布式 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31259663/article/details/129830667
版权

1.同一个锁key，同一时间只能有一个客户端拿到锁，其他客户端会陷入无限的等待来尝试获取那个锁，只有获取到锁的客户端才能执行下面的业务逻辑。

2.引入依赖 aop redis 

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

这里基于自定义注解引入spring的spel表达式 类似于 

@Cacheable 缓存注解中参数

 

   <!--spel表达式-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
        </dependency>

3.具体锁业务方法

package org.xiaozhang.common.Lock;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.stereotype.Component;

import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;

/**
 * @author Mr.Zhang
 * @version 1.0.0
 * @description:
 * @since 2023/3/27 17:30
 */
@Component
public class RedisLockService {
    private static Logger log = LoggerFactory.getLogger(RedisMutexAop.class);
    private static String UNLOCK_LUA;

    static {
        //如果存在删除返回true
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();
    }

    private RedisTemplate redisTemplate;

    private RedisLockService(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * @param keyCode
     * @param keyValue
     * @param expire          key有效期
     * @param maxWaitLockTime 最大等待锁时间
     * @return
     */
    public boolean getLock(String keyCode, String keyValue, long expire, long maxWaitLockTime) {
        //最先开始时间
        long startTime = System.currentTimeMillis();
        return getLock(keyCode, keyValue, expire, startTime, maxWaitLockTime,0);
    }

    public boolean getLock(RedisMutexDo redisMutexDo) {
        //最先开始时间
        long startTime = System.currentTimeMillis();
        return getLock(redisMutexDo.getKeyCode(), redisMutexDo.getKeyValue(), Long.valueOf(redisMutexDo.getExprire()), startTime, Long.valueOf(redisMutexDo.getMaximumTime()),0);
    }

    /**
     * @param keyCode
     * @param keyValue
     * @param expire          key有效期
     * @param startTime       最先获取锁的开始时间戳(秒)
     * @param maxWaitLockTime 最大等待锁时间(秒)
     * @return
     */
    private boolean getLock(String keyCode, String keyValue, long expire, long startTime, long maxWaitLockTime,int executions) {
        log.info("当前线程:{}试图第{}次开始获取锁keyCode:{},keyValue:{}",Thread.currentThread().getName(),executions,keyCode,keyValue);
        //获取唯一互斥锁
        if (tryGetDistributedLock(keyCode, keyValue, expire)) {
            return true;
        } else {
            //等待时间超过n秒种直接返回
            long l = System.currentTimeMillis() - startTime;
            log.debug("{}等待时长为:{}",Thread.currentThread().getName(),l*0.001);
            if ((l)*0.001 > maxWaitLockTime) {
                System.out.println("当前资源拼缝,请重试");
                return false;
            }
            // 这里延迟2秒种在次获取
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                //异常都返回相同 资源异常
                return false;
            }
            //重新获取
            return getLock(keyCode, keyValue, expire, startTime,maxWaitLockTime,executions+1);
        }
    }

    /**
     * 获取keycode 当不存在时候返回true 并设置过期时间
     *
     * @param keyCode  key
     * @param keyValue 随便
     * @param expire   超时时间 seconds
     * @return
     */
    private boolean tryGetDistributedLock(String keyCode, String keyValue, long expire) {
        try {
            RedisCallback<Boolean> callback = (connection) -> {
                return connection.set(keyCode.getBytes(Charset.forName("UTF-8")), keyValue.getBytes(Charset.forName("UTF-8")), Expiration
                        .seconds(expire), RedisStringCommands.SetOption.SET_IF_ABSENT);
            };
            return (Boolean) this.redisTemplate.execute(callback);
        } catch (Exception var6) {
            System.out.println("set redis occured an exception" + var6);
            return false;
        }
    }

    /**
     * 释放锁
     */
    public boolean releaseDistributedLock(String keyCode, String keyValue) {
        try {
            RedisCallback<Boolean> callback = (redisConnection) -> {
                return (Boolean) redisConnection.eval(UNLOCK_LUA.getBytes(Charset.forName("UTF-8")), ReturnType.BOOLEAN, 1, new byte[][]{keyCode.getBytes(Charset.forName("UTF-8")), keyValue.getBytes(Charset.forName("UTF-8"))});
            };
            boolean var6 = (Boolean) this.redisTemplate.execute(callback);
            return var6;
        } catch (Exception var10) {
            return false;
        } finally {
            ;
        }
    }

    /**
     * 释放锁信息
     */
    public String getLockInfo(String keyCode) {
        try {
            RedisCallback<String> callback = (redisConnection) -> new String(redisConnection.get(keyCode.getBytes(Charset.forName("UTF-8"))));
            return (String) this.redisTemplate.execute(callback);
        } catch (Exception var10) {
            log.error("error get keyCode:{} Exception:{}", keyCode, var10);
            return "";
        }
    }
}

4.编写自定义注解

package org.xiaozhang.common.Lock;

import java.lang.annotation.*;

/**
 * @author Mr.Zhang
 * @version 1.0.0
 * @description: redis分布式互斥锁
 * @since 2023/3/27 16:12
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisMutexLock {
    /**
     * key
     * @return
     */
    String keyCode() default "";

    /**
     * keyValue
     * @return
     */
    String keyValue() default "";
    /**
     * key过期时间
     * @return  默认3分钟
     */
    String exprire() default "18000";

    /**
     * 最大等待时间 默认2分钟
     * @return
     */
    String maximumTime() default "12000";

}

4.2 创建参数对象

package org.xiaozhang.common.Lock;

/**
 * @author Mr.Zhang
 * @version 1.0.0
 * @description:
 * @since 2023/3/27 16:26
 */
public class RedisMutexDo {
    private String keyCode;
    private String keyValue;
    /**
     * 最大等待时间 默认2分钟(秒)
     * @return
     */
    private String exprire;
    /**
     * 最大等待时间 默认3分钟(秒)
     * @return
     */
    private String maximumTime;
    public RedisMutexDo(){}
    public RedisMutexDo(String keyCode, String keyValue) {
        this.keyCode = keyCode;
        this.keyValue = keyValue;
        this.exprire = "120";
        this.maximumTime = "180";
    }
    public RedisMutexDo(String keyCode, String keyValue, String exprire, String maximumTime) {
        this.keyCode = keyCode;
        this.keyValue = keyValue;
        this.exprire = exprire;
        this.maximumTime = maximumTime;
    }

    public String getKeyCode() {
        return keyCode;
    }

    public void setKeyCode(String keyCode) {
        this.keyCode = keyCode;
    }

    public String getKeyValue() {
        return keyValue;
    }

    public void setKeyValue(String keyValue) {
        this.keyValue = keyValue;
    }

    public String getExprire() {
        return exprire;
    }

    public void setExprire(String exprire) {
        this.exprire = exprire;
    }

    public String getMaximumTime() {
        return maximumTime;
    }

    public void setMaximumTime(String maximumTime) {
        this.maximumTime = maximumTime;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("RedisMutexDo{");
        sb.append("keyCode='").append(keyCode).append('\'');
        sb.append(", keyValue='").append(keyValue).append('\'');
        sb.append(", exprire='").append(exprire).append('\'');
        sb.append(", maximumTime='").append(maximumTime).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

4.3 创建aop切面类

package org.xiaozhang.common.Lock;

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.CodeSignature;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.xiaozhang.common.exception.OrderException;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

/**
 * @author Mr.Zhang
 * @version 1.0.0
 * @description:
 * @since 2023/3/27 16:13
 */
@Aspect
@Component
public class RedisMutexAop {
    private static Logger log = LoggerFactory.getLogger(RedisMutexAop.class);

    @Autowired
    private RedisLockService redisLockService;

    /***
     * 切入点
     */
    @Pointcut("@annotation(org.xiaozhang.common.Lock.RedisMutexLock)")
    public void pointCut() {
    }

    /*****
     * 环绕通知
     * @param point
     * @return
     */
    @Around("pointCut()")
    public Object aroundAdvice(ProceedingJoinPoint point) throws Throwable {
        Object obj = null;
        //获取方法参数
        Method month = getMonth(point);
        //获取map<参数名,参数值>
        Map<String, Object> param = getParam(point);
        //获取锁注解
        RedisMutexLock annotation = month.getAnnotation(RedisMutexLock.class);
        //锁的参数
        RedisMutexDo redisMutexDo = replaceRedisMutexLock(param, annotation);
        //获取锁
        if (redisLockService.getLock(redisMutexDo)) {
            log.info("当前线程{}获取锁,开始执行业务方法",Thread.currentThread().getName());
            //执行目标方法
            obj = point.proceed();
        } else {
            //不执行返回并抛出异常
            log.error("获取分布式锁失败");
            throw new OrderException("获取分布式锁失败");
        }
        if (redisLockService.releaseDistributedLock(redisMutexDo.getKeyCode(), redisMutexDo.getKeyValue())) {
            //释放锁
            log.info("当前线程{}成功释放锁",Thread.currentThread().getName());
        } else {
            //释放失败
            log.error("释放失败{}",redisLockService.getLockInfo(redisMutexDo.getKeyCode()));
        }
        return obj;
    }

    /**
     * 获取参数名和参数值
     * @param proceedingJoinPoint
     * @return
     */
    private Map<String, Object> getParam(ProceedingJoinPoint proceedingJoinPoint) {
        Map<String, Object> map = new HashMap<String, Object>();
        Object[] values = proceedingJoinPoint.getArgs();
        String[] names = ((CodeSignature) proceedingJoinPoint.getSignature()).getParameterNames();
        for (int i = 0; i < names.length; i++) {
            map.put(names[i], values[i]);
        }
        return map;
    }

    /**
     * 获取ProceedingJoinPoint 代理的方法对象
     *
     * @param point
     * @return
     */
    private Method getMonth(ProceedingJoinPoint point) {
        Class<?> targetCls = point.getTarget().getClass();
        //获取方法签名(通过此签名获取目标方法信息)
        MethodSignature ms = (MethodSignature) point.getSignature();
        //获取目标方法上的注解指定的操作名称
        Method targetMethod = null;
        try {
            targetMethod = targetCls.getDeclaredMethod(
                    ms.getName(),
                    ms.getParameterTypes());
        } catch (NoSuchMethodException e) {
            log.error("未找到方法异常{}", e);
        }
        return targetMethod;
    }

    /**
     * 获取当前执行方法中参数中包含#字段值或者RedisMutexDo对象中参数
     *
     * @param args
     * @param annotation
     * @return 返回锁的参数
     */
    private RedisMutexDo replaceRedisMutexLock(Map<String, Object> param, RedisMutexLock annotation) {
        RedisMutexDo redisMutexDo = new RedisMutexDo();
        // 创建ExpressionParser解析表达式
        ExpressionParser parser = new SpelExpressionParser();
        // 创建一个虚拟的容器EvaluationContext
        StandardEvaluationContext ctx = new StandardEvaluationContext();
        //遍历注解中参数属性
        SpelExpression keyCode= null;
        if (checkSignStart(annotation.keyCode(),"#")){
            keyCode = Optional.ofNullable(annotation.keyCode())
                    .map(k -> (SpelExpression) parser.parseExpression(annotation.keyCode())).orElse(null);
        }
        SpelExpression keyValue= null;
        if (checkSignStart(annotation.keyValue(),"#")){
            keyValue =  Optional.ofNullable(annotation.keyValue())
                    .map(k->(SpelExpression)parser.parseExpression(annotation.keyValue())).orElse(null);
        }
        SpelExpression exprire=null;
        if (checkSignStart(annotation.exprire(),"#")){
            exprire =   Optional.ofNullable(annotation.exprire()).map(k->k.contains("#"))
                    .map(k->(SpelExpression)parser.parseExpression(annotation.exprire())).orElse(null);
        }
        SpelExpression maximumTime= null;
        if (checkSignStart(annotation.maximumTime(),"#")){
            maximumTime= Optional.ofNullable(annotation.maximumTime()).map(k->k.contains("#"))
                    .map(k->(SpelExpression)parser.parseExpression(annotation.maximumTime())).orElse(null);
        }
        //遍历参数和对应值
        param.forEach((k,v)->{
            ctx.setVariable(k, v);
        });
        //赋值
        redisMutexDo.setKeyCode(keyCode!=null?(String) keyCode.getValue(ctx):annotation.keyCode());
        redisMutexDo.setKeyValue(keyValue!=null?(String) keyValue.getValue(ctx):annotation.keyValue());
        redisMutexDo.setExprire(exprire!=null?(String) exprire.getValue(ctx):annotation.exprire());
        redisMutexDo.setMaximumTime(maximumTime!=null?(String) maximumTime.getValue(ctx):annotation.maximumTime());
        return redisMutexDo;
    }

 

    /**
     * 检查字符串是否以符号开头
     * @param str 字符串
     * @param sign 符号
     * @return
     */
    private boolean checkSignStart(String str,String sign){
        if (str == null || "".equals(str)){
            return false;
        }
        //去除前后字符串
        if (str.trim().lastIndexOf(sign)==0){
            return true;
        }
        return false;
    }
}

5.开始业务测试 创建个业务方法并重写两种方式

  //车数
    public static int cs=100;

    @RedisMutexLock(keyCode = "#keyCode",keyValue = "#keyValue",exprire = "#exprire",maximumTime = "#maximumTime")
    public JsonResponse getLock(String keyCode,String keyValue,String exprire,String maximumTime){
        RedisMutexDo redisMutexDo = new RedisMutexDo(keyCode,keyValue,exprire,maximumTime);
        return this.getLock(redisMutexDo);
    }
    @RedisMutexLock(keyCode = "#redisMutexDo.keyCode",keyValue = "#redisMutexDo.keyValue",exprire = "#redisMutexDo.exprire",maximumTime = "#redisMutexDo.maximumTime")
    public JsonResponse getLock(RedisMutexDo redisMutexDo) {
        try {
            //睡个20秒
            TimeUnit.SECONDS.sleep(20);
        } catch (InterruptedException e) {
            log.error("中断异常:{}",e);
        }
        log.info("获得了锁进入业务方法");
        cs=cs-1;
        return JsonResponse.ok(redisMutexDo).setMessage("抢到");
    }

 5.2 开始用测试类去测试 

这里一开始没有启动redis服务,现在处于连接失败状态,不过资源还在一直尝试抢锁,

2秒抢一次锁，最大等待时间/2=抢锁次数这里做了打印

180/2=大约重试锁60次，就会结束抛出异常不再执行业务方法。

 

头发哐哐掉
关注
专栏目录
分布式锁基于【注解】，杜绝业务重复提交。动态key
SharingOfficer的博客
12-20 707
前言 在日常开发中，为了防止高并发，在不依赖过多的中间件的情况下，最常使用的分布式锁之一是Redis锁。使用Redis锁就不得不面临一个问题，就是在业务代码中要控制Redis加锁、释放锁等等，对代码的侵入性较强。本文采用注解的方式为方法体增加分布式锁，唯一标识从方法参数中动态获取。 优点 无侵入。通过注解实现加锁和释放锁，代码中只需关注业务实现，无须关心“锁”问题，避免代码侵入。 无死锁。即使某一线程中断没能释放锁，在到达指定的时间后，程序会自动释放锁。 锁唯一独有。加锁和释放锁必须由同一线...
redis 分布式锁
weixin_58361879的博客
06-20 906
redis手写分布式锁
自定义redis锁注解
逆光世间
12-11 308
项目中经常使用的redis锁写起来十分繁琐, 同样的代码需要编写多次. 于是想到使用注解方式来解决 0.1. 构思 由于使用注解不能确定返回值, 所以采用自定义异常的方式来解决 redis锁一般需要指定过期时间, 考虑到特殊情况设置默认过期时间为永久 0.2. 启动类1 2 3 4 5 6 7 8 9 // 开启AOP代理自动配置 // exposeProxy = ...
Redis的分布式锁详解
最新发布
Lsd2176647391的博客
08-13 6318
（3）为了有效解决既保证锁完全有效性 和 性能高效问题：antirez又提出了“延迟重启”的概念，redis同步到磁盘方式保持默认的每秒1次，在redis崩溃单机后（无论是一个还是所有），先不立即重启它，而是等待TTL时间后再重启，这样的话，这个节点在重启前所参与的锁都会过期，它在重启后就不会对现有的锁造成影响，缺点是在TTL时间内服务相当于暂停状态；分布式事务锁中，为了能够让作为中心节点的存储节点获取锁的持有者，从而避免锁被非持有者误解锁，每个发起请求的 client 节点都必须具有全局唯一的 id。
java中锁的注解_【完美】SpringBoot中使用注解来实现 Redis 分布式锁
weixin_36221980的博客
03-02 728
一、业务背景有些业务请求，属于耗时操作，需要加锁，防止后续的并发操作，同时对数据库的数据进行操作，需要避免对之前的业务造成影响。二、分析流程使用Redis作为分布式锁，将锁的状态放到Redis统一维护，解决集群中单机JVM信息不互通的问题，规定操作顺序，保护用户的数据正确。梳理设计流程新建注解 @interface，在注解里设定入参标志增加 AOP 切点，扫描特定注解建立 @Aspec...
redis锁-注解版
activety的博客
06-05 772
Redis实现分布式锁利用 SETNX 和 SETEX 基本命令主要有： SETNX(SET If Not Exists)： 当且仅当 Key 不存在时，则可以设置，否则不做任何动作。 当且仅当 key 不存在，将 key 的值设为 value ，并返回1；若给定的 key 已经存在，则 SETNX 不做任何动作，并返回0。 SETEX： 基于SETNX功能外,还可以设置超时时间，防止死锁。 项目图 代码实现 application.yml # Redis数据库索引（默认为0） spring.redis.
注解方式实现Redis锁
Mr.xie1024的博客
05-09 228
【代码】注解方式实现Redis锁。
Redis分布式锁解决接口幂等的两种方案
12-21
本文将探讨通过Redis分布式锁来解决这一问题的两种方案。 ### 一、分布式锁基本概念 分布式锁是一种在分布式系统中控制资源访问的机制，确保在分布式环境中同一时刻只有一个客户端能够访问特定的资源。Redis作为...
记录redisson实现redis分布式事务锁
04-24
本篇文章将详细探讨如何使用Redisson实现Redis分布式事务锁，以及在Spring Boot环境中如何进行集成。 首先，Redis作为一个内存数据库，其高速读写性能使其成为实现分布式锁的理想选择。分布式锁的主要作用是在多...
自定义注解+切面+Redis实现简单的分布式锁
g54469的博客
09-09 508
分布式锁使用场景 在单机模式下，如果一段代码限制同一时刻只能一个线程去访问，我们会使用并发锁来解决； 但是现在项目一般是微服务集群部署，并发锁的锁作用域只在当前服务器的JVM中，多个服务器的并发锁不起作用。 这就有了分布式锁的概念：保证代码在不同服务器之间只允许一个线程执行。 开干 冲冲冲！！！ 这里做个测试用例，开放一个接口，先进行token校验，再返回请求的数据（假设这个是对某条对应数据的修改操作，不让调用方重复请求之类的操作） 1、定义一个自定义注解，凡使用到这个注解的方法都先进入切面去校验token
Java三种方式实现redis分布式锁
Ajekseg的博客
08-01 2102
在分布式服务中，常常有如定时任务、库存更新这样的场景。在定时任务中，如果不使用quartz这样的分布式定时工具，只是简单的使用定时器来进行定时任务，在服务分布式部署中，就有可能存在定时任务并发执行，造成一些问题。在库存更新这样的场景中，我们服务对数据库同一条记录进行更新，并记录。对记录更新可以使用分布式锁，但对操作进行记录时，可能造成读未提交，造成记录错乱的情况。在以上的场景中，我们引入了分布式事务锁。...
AOP+自定义注解+Redis实现分布式锁
小学生波波
10-29 2809
AOP+自定义注解+Redis实现分布式锁
Redis缓存自定义注解
weixin_43326384的博客
01-29 235
package com.my.cache; import java.lang.reflect.Method; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.Signature; import org.aspectj.lang.annot...
使用自定义注解实现Redis分布式锁
热门推荐
一恍过去
06-29 2万+
使用自定义注解实现Redis分布式锁
利用Redis实现单例锁自定义注解
weixin_42558461的博客
08-18 431
自定义注解利用redis实现单例锁
redis分布式锁 做成注解 , 超好用 !
weixin_43786801的博客
09-24 844
redis分布式锁 做成注解
自定义注解实现
weixin_43975276的博客
06-07 1678
实现自定义注解其实很简单，格式基本都差不多。也就参数可能变一变。
使用注解实现 Redis 分布式锁，看了秒懂！
m0_71777195的博客
03-29 326
一、业务背景有些业务请求，属于耗时操作，需要加锁，防止后续的并发操作，同时对数据库的数据进行操作，需要避免对之前的业务造成影响。二、分析流程使用Redis作为分布式锁，将锁的状态放到Redis统一维护，解决集群中单机JVM信息不互通的问题，规定操作顺序，保护用户的数据正确。梳理设计流程1、2、3、4、5、
自己实现的一个redis锁注解
半斤米粉闯天下的博客
09-14 298
@Slf4j @Aspect @Component public class SynchronizeLockAspect { private static final String KEY = "thread_lock"; private final ThreadLocal<String> threadLocal = new ThreadLocal<>(); private final StringRedisTemplate stringRedisTemp
redis分布式锁spring注解
08-26
对于使用Redis分布式锁的Spring注解，可以使用`@DistributedLock`注解来实现。你可以自定义一个注解，如下所示： ```java @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface DistributedLock { String value() default ""; // 锁的名称，可以为空，默认为方法名 long expire() default 30000; // 锁的过期时间，默认为30秒 TimeUnit timeUnit() default TimeUnit.MILLISECONDS; // 过期时间单位，默认为毫秒 } ``` 然后，你可以在需要加锁的方法上使用`@DistributedLock`注解，如下所示： ```java @Service public class SomeService { @DistributedLock("lockName") public void doSomething() { // 加锁后的业务逻辑 // ... } } ``` 在上面的例子中，`@DistributedLock`注解中的参数 `"lockName"` 是锁的名称，你也可以不指定，默认为方法名。`expire` 和 `timeUnit` 分别用于设置锁的过期时间和过期时间单位。 当方法被调用时，会尝试获取指定名称的分布式锁，如果成功获取到锁，则执行业务逻辑。如果获取锁失败，则会等待或抛出异常，具体取决于你选择的分布式锁实现方式。 需要注意的是，你需要集成一个Redis分布式锁的实现库，如`redisson`、`jedis`等，并进行相应的配置。这样Spring才能识别并处理`@DistributedLock`注解。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值