Redis 分布式锁 @Klock 注解详解及使用教程

已于 2023-10-10 21:07:16 修改
阅读量1.1k 收藏 6
点赞数 2
分类专栏： java程序实现 文章标签： redis 分布式锁
于 2023-10-10 16:21:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/demo_yo/article/details/127086421
版权

文章目录

一、作用

注解 @klock 是基于 Redis 的分布式锁，作用在分布式事务中避免并发冲突。只作用于方法上。

二、参数

  1. name：锁的名称。锁唯一标识。

  2. keys：加锁 id。加锁对象的唯一标识。

  3. lockType：锁类型。默认可重入锁。

     LockType.Reentrant 可重入锁。默认。
 LockType.Fair 公平锁。
 LockType.Reentrant 读锁。
 LockType.Reentrant 写锁。

  4. waitTime：获取锁最长等待时间。单位秒。

  5. leaseTime：获取到锁后，自动释放锁的时间。

  6. lockTimeoutStrategy：获取锁超时的处理策略。默认 NO_OPERATION 继续执行业务逻辑，不做任何处理。

     NO_OPERATION：不做处理，不加锁继续执行业务逻辑。（默认）
 FAIL_FAST：快速失败，直接抛出获取锁超时异常。
 KEEP_ACQUIRE：阻塞等待，一直阻塞，直到获得锁，在太多的尝试后，仍会报错。
 		       一般下一次获取锁的间隔时间初始为0.1秒、总共尝试次数为10次，下一次获取锁的时间间隔会成倍增长。很可能引起死锁。

  7. customLockTimeoutStrategy：自定义加锁超时的处理策略。String 类型，当前类中的方法名。会覆盖 lockTimeoutStrategy 的处理策略。

     自定义处理方法，方法参数必须与加锁的方法参数一致。

  8. releaseTimeoutStrategy：占有锁超时的处理策略。默认 NO_OPERATION 继续执行业务逻辑，不做任何处理。

     NO_OPERATION：不做处理，不加锁继续执行业务逻辑。（默认）
 FAIL_FAST：快速失败，直接抛出获取锁超时异常。

  9. customReleaseTimeoutStrategy：自定义释放锁时已超时的处理策略。String 类型，当前类中的方法名。会覆盖 releaseTimeoutStrategy 的处理策略。

     自定义处理方法，方法参数必须与加锁的方法参数一致。

三、锁的流程

在这里插入图片描述

四、SpringBoot 集成

1. pom 依赖

<!--klock-->
<dependency>
	<groupId>cn.keking</groupId>
	<artifactId>spring-boot-klock-starter</artifactId>
	<version>1.4-RELEASE</version>
</dependency>

2. yaml 配置

  1. 单节点配置
spring:
  klock:
    #单节点地址
    address: 192.168.0.193:6379
    #密码，没有密码就不要配置password
    #password:
    #获取锁最长阻塞时间（默认：60，单位：秒）
    wait-time: 20
    #已获取锁后自动释放时间（默认：60，单位：秒）
    lease-time: 20
  1. 集群配置
spring:
  klock:
    #密码
    #password:
    #获取锁最长阻塞时间（默认：60，单位：秒）
    wait-time: 20
    #已获取锁后自动释放时间（默认：60，单位：秒）
    lease-time: 20
    #集群配置
    cluster-server:
    node-addresses: 192.168.0.111:6379,192.168.0.112:6379,192.168.0.113:6379,192.168.0.101:6379,192.168.0.102:6379,192.168.0.103:6379,192.168.0.114:6379,192.168.0.104:6379

3. 使用方式

/**
 * 根据id查询
 *
 * @param id 文章id
 * @return 文章
 */
@Override
@Klock(name = "article-hist-lock", // 锁名称
 		keys = "#id", // 加锁id
        lockType = LockType.Fair, // 锁类型；公平锁
        waitTime = 10, // 获取锁最长等待时间：10s
        leaseTime = 300, // 获得锁后，自动释放锁的时间：300s
        lockTimeoutStrategy = LockTimeoutStrategy.FAIL_FAST, // 获取锁超时的处理策略：直接返回失败
        releaseTimeoutStrategy = ReleaseTimeoutStrategy.FAIL_FAST) // 占有锁超时的处理策略：直接返回失败
public CmsArticleVo selectCmsArticleVoByIdForApi(Long id) {
    // 设置查询文章的内容类型
    String contentType = CmsConstants.CONTENT_TYPE_ARTICLE;
    CmsArticleVo cmsArticleVo = cmsArticleMapper.selectCmsArticleVoById(id, contentType);
    if (cmsArticleVo != null) {
        // 文章点击量+1
        CmsArticle cmsArticle = new CmsArticle();
        cmsArticle.setId(cmsArticleVo.getId());
        cmsArticle.setHist(cmsArticleVo.getHist() + 1);
        cmsArticleMapper.updateById(cmsArticle);
    }
    return cmsArticleVo;
}

五、变量级锁和方法级锁

VariableAndMethodLockService

package com.alian.redisklock.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.klock.annotation.Klock;
import org.springframework.boot.autoconfigure.klock.model.LockTimeoutStrategy;
import org.springframework.stereotype.Service;

@Slf4j
@Service
public class VariableAndMethodLockService {

    /**
     * 变量级加锁
     * @param userId
     */
    @Klock(keys = "#userId", lockTimeoutStrategy = LockTimeoutStrategy.FAIL_FAST)
    public void variableLock(String userId) {
        log.info("变量级加锁收到的消息:{}", userId);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("变量级加锁业务处理完:{}", userId);
    }

    /**
     * 方法级加锁
     * @param userId
     */
    @Klock
    public void methodLock(String userId) {
        log.info("方法级加锁收到的消息:{}", userId);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("方法级加锁业务处理完:{}", userId);
    }
}

使用5个线程来进行并发验证：

TestLockTypeService

package com.alian.redisklock.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.concurrent.CountDownLatch;

@Slf4j
@Service
public class TestLockTypeService {

    private final CountDownLatch countDownLatch = new CountDownLatch(1);

    @Autowired
    private VariableAndMethodLockService vmService;

    @PostConstruct
    public void testVariableAndMethodLock() {
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(() -> {
                try {
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //变量级加锁
                vmService.variableLock("10001_" + finalI);
                //方法级加锁
//                vmService.methodLock("10002_"+ finalI);
            }, "Thread" + i).start();
        }
        countDownLatch.countDown();
    }

}

变量级加锁结果

2023-09-23 17:42:15 432 [Thread0] INFO :变量级加锁收到的消息:10001_0
2023-09-23 17:42:15 432 [Thread1] INFO :变量级加锁收到的消息:10001_1
2023-09-23 17:42:15 432 [Thread4] INFO :变量级加锁收到的消息:10001_4
2023-09-23 17:42:15 432 [Thread2] INFO :变量级加锁收到的消息:10001_2
2023-09-23 17:42:15 432 [Thread3] INFO :变量级加锁收到的消息:10001_3
2023-09-23 17:42:16 439 [Thread3] INFO :变量级加锁业务处理完:10001_3
2023-09-23 17:42:16 439 [Thread2] INFO :变量级加锁业务处理完:10001_2
2023-09-23 17:42:16 439 [Thread0] INFO :变量级加锁业务处理完:10001_0
2023-09-23 17:42:16 439 [Thread4] INFO :变量级加锁业务处理完:10001_4
2023-09-23 17:42:16 439 [Thread1] INFO :变量级加锁业务处理完:10001_1

方法级加锁结果

2023-09-23 17:43:15 779 [Thread3] INFO :方法级加锁收到的消息:10002_3
2023-09-23 17:43:16 787 [Thread3] INFO :方法级加锁业务处理完:10002_3
2023-09-23 17:43:16 797 [Thread2] INFO :方法级加锁收到的消息:10002_2
2023-09-23 17:43:17 800 [Thread2] INFO :方法级加锁业务处理完:10002_2
2023-09-23 17:43:17 819 [Thread0] INFO :方法级加锁收到的消息:10002_0
2023-09-23 17:43:18 833 [Thread0] INFO :方法级加锁业务处理完:10002_0
2023-09-23 17:43:18 844 [Thread1] INFO :方法级加锁收到的消息:10002_1
2023-09-23 17:43:19 847 [Thread1] INFO :方法级加锁业务处理完:10002_1
2023-09-23 17:43:19 863 [Thread4] INFO :方法级加锁收到的消息:10002_4
2023-09-23 17:43:20 864 [Thread4] INFO :方法级加锁业务处理完:10002_4

结论：

  • 变量级锁，针对的是一个变量，变量不同，获取的锁就不存在先后顺序，都可以获取到自己的锁。
  • 方法级锁，针对的是方法，哪怕请求值不一样，也只能一个线程获取到锁，直到释放后，下一个线程才能获取。
  • 变量级锁的效率更适合高并发场景，而方法级锁可能引起阻塞。

六、常见应用场景

1. 页面重复提交

最常见的就比如手机端录入信息到后台，比如注册之类的等等，用户端可能因为各种原因可能会点击多次，导致后台可能会出现多笔记录的情况，这个时候很简单，用到我们的锁，假设，我们是注册用户，手机号是唯一的。

@Klock(keys = "#phone", lockTimeoutStrategy = LockTimeoutStrategy.FAIL_FAST)
@RequestMapping("register")
public void register(String phone,String nickName) {
    log.info("注册账户收到的信息:{},{}", phone,nickName);
    try {
        //模拟业务过程
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.info("注册账户业务处理完");
}

这个时候，如果是点击了两次，第一次业务进入获取到锁进行处理，第二过来了也是一个等待，要么第一次处理完成，第二次业务判断已注册，要么第二次直接超时了。

2. 定时任务

工作中定时任务使用还是蛮多的，但是也会有很多问题，当遇到分布式服务时，一个服务部署多台，定时任务就可能会同时运行，这种情况怎么处理呢？有些人可能会给两个服务的配置改成不一样，比如定时任务的时间修改，一个正常执行，一个在不可能的时间执行，还有人直接给服务设置一个标志位，只有某个标志位的能执行。好吧，在分布式环境，并且服务不是很多的情况下，也许还能勉强维护，那么如果是容器下呢？所以分布式锁的方案就更加重要了。

@Scheduled(cron = "0 0 2 * * ?")
public void dataCollector(){
    //开始做任务
    String dataTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));
    createDataFile(dataTime);
    //结束任务
}

@Klock(keys = "#dataTime", lockTimeoutStrategy = LockTimeoutStrategy.FAIL_FAST)
public void createDataFile(String dataTime) {
    log.info("开始生成对账文件:{}", dataTime);
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.info("对账文件生成完成:");
}

这是一个示例，实际中，createDataFile方法是另外一个service中的方法，这样不管是单机，分布式多机，还是在容器中都只有一个定时任务在执行，而不会导致重复数据问题。

3. 核心业务

其实这个场景是用的最多的，比如商品库存的扣减，因为我们不能超卖啊。实际工作中，需要根据自己的业务定义特定意义的key就可以了。

@Klock(keys = "#goodId", lockTimeoutStrategy = LockTimeoutStrategy.FAIL_FAST)
public void deductCommodityInventory(String goodId,int num) {
    log.info("商品【{}】扣减库存:{}", goodId,num);
    //扣减库存操作
    //dosomething()
    log.info("商品扣减库存完成");
}

七、锁的粒度与锁的时间

锁的粒度一定要把握好，不能过小或者过大。能使用粒度小的锁，就尽量使用。比如尽量使用粒度更小的变量级锁，而不是方法级锁。尽量使用对象的唯一性字段作为锁的 key，而不是对象。

锁的时间控制一定要合理，不能太长也不能太短，根据相应的需求来合理设置以达到较好的性能。包括等待时间、释放时间、超时策略的时间响应问题。

Whitemeen太白
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【项目实战】Redis使用场景之基于Redis的分布式锁（spring-boot-klock-starter）实现支付回调接口
本本本添哥
05-14 37
spring-boot-klock-starter是基于Redis的分布式锁spring-boot starter组件spring-boot-klock-starter使得项目拥有分布式锁能力变得异常简单spring-boot-klock-starter支持spring boot，和spirng mvc等spring相关项目。
spring-boot-klock-starter分布式锁项目开源
Javaseo996的博客
06-08 1041
前言spring-boot-klock-starter是一个基于redis的分布式锁spring boot starter组件，使得项目拥有分布式锁能力变得异常简单，支持spring boot，和spirng mvc等spring相关项目，使用和接入都非常简单方便，现开源出来，给所有需要分布式锁能力的项目提供一个方案快速开始spring boot项目接入1.添加lock starter组件依赖，目前还没上传到公共仓库，需要自己下源码buildorg.springframework.bootspring-bo
注解方式实现Redis锁
最新发布
Mr.xie1024的博客
05-09 151
【代码】注解方式实现Redis锁。
spring-boot-klock-starter：基于redis的分布式锁组件，简单方便快捷插入项目，使项目拥有分布式锁能力
01-30
弹簧启动klock启动器 基于redis的分布式锁spring-boot starter组件，由于项目拥有多样化的锁能力变得异常简单，支持spring boot，和spirng mvc等spring相关项目 快速开始 弹簧靴 1.添加锁启动器组件依赖，目前还没上传到公共仓库，需要自己下源码build ，已上传到maven中央仓库 <dependency> <groupId>cn.keking</groupId> <artifactId>spring-boot-klock-starter</artifactId> <version>1.4-RELEASE</version> </dependency> 2.application.properties配置redis链接：spring.klock.address = 127.0.0.1：6379 3.在需要加分布式锁的方法上，添加注解@Klock，如： @Service public class TestService { @Klock ( waitTime = Long . MAX_VALUE )
# **SpringBoot** 分布式锁 @klock详解
itScholar001的博客
06-26 1111
默认为：lock.包名.类名-方法名。releaseTimeoutStrategy: 释放锁时，持有的锁已超时的处理策略，可配置为不做处理、快速失败的处理策略，默认策略为不做处理。lockTimeoutStrategy: 加锁超时的处理策略，可配置为不做处理、快速失败、阻塞等待的处理策略，默认策略为不做处理。customLockTimeoutStrategy: 自定义加锁超时的处理策略，需指定自定义处理的方法的方法名，并保持入参一致。lockType：锁的类型，目前支持（可重入锁，公平锁，读写锁）。
Springboot集成Klock简单实现分布式锁
qq_25156781的博客
10-27 520
同一个方法，不同参数，来修改一个hash结构缓存的不同field，可以将field作为二级key，那么不同的field就有不同的lockKey，不会互相影响的业务，就可以不用阻塞了。但是如果是订单中，同一个订单中有不同的品名ID的商品，这些品名对应不同的key，在下单的时候，防止超卖，每个品命的库存都需要被保护的，即使其他的业务方法，想修改多个key中的其中的一个key，都不行，那么@Klock的注解实现方式就不可行。lockType：锁的类型，目前支持（可重入锁，公平锁，读写锁）。
@Klock注解接口内的方法体不能修改参数值，否则返回报错ex=null，空指针
zh_chong的博客
01-22 1070
@Klock(keys = {"#ordersDto.itemId", "#ordersDto.itemType", "#ordersDto.userId"}) 创建订单的接口添加上面的注解了，在方法体中修改了itemId值，返回时一直报错空指针，ex=null。 优化方法，可以创建一个新的对象接收参数，然后使用新的对象去做，可以修改属性值。 OrdersDto ordersDtoTemp = BeanUtil.copyProperties(ordersDto, OrdersDto.class); .
Java Redis分布式锁的正确实现方式详解
08-25
Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...
C#实操控制并发之Lock和Redis分布式锁
01-21
本文将深入探讨C#中如何使用Lock和Redis分布式锁来解决并发问题，以秒杀系统为例进行阐述。 首先，让我们理解什么是并发控制。并发控制是指在多线程环境下确保数据的一致性和完整性，防止多个线程同时访问同一资源...
Redis分布式锁的实现方式(redis面试题)
09-08
分布式锁是一种在分布式系统中实现锁的机制，用于协调分布在不同节点上的进程对共享资源的访问。在单机系统中，我们通常使用线程锁（如Java中的`synchronized`关键字或`java.util.concurrent.locks.Lock`接口）来...
浅析Redis分布式锁
12-16
前期考虑的方案有采用ZooKeeper分布式任务,Quartz分布式任务调度,但是由于Zookeeper需要增加额外组件,Quartz需要增加表,并且项目中现在已经有Redis这一组件存在,所以考虑采用Redis分布式锁的情况来完成分布式任务...
分布式锁——redis实现
u010266988的博客
03-30 466
使用Redis实现了一个锁，命名为：RedisLock。 一、原理介绍 1.1 RedisLock特性 用最简单的方式实现一个redis分布式锁，该锁具有如下特性： 阻塞式：在加锁时，如果获取不到，则进入自旋状态； 非阻塞式：在加锁时，如果获取不到，立刻返回加锁失败； 可重入：同一个线程多次请求加锁，对资源做+1操作，解锁时，资源必须等于0才算完全解除锁定； 锁超时：加锁时，可以设置...
分布式锁使用说明，分布式锁快速集成使用
weixin_43538316的博客
05-29 230
spring.klock.address 和 spring.klock.cluster-server.node-addresses 选其一即可。2). 秒杀场景，要求并发量很高，那么同一件商品只能被一个用户抢到，那么就可以使用分布式锁实现。spring.klock.leaseTime：已获取锁后自动释放时间（默认：60，单位：秒）spring.klock.waitTime ：获取锁最长阻塞时间（默认：60，单位：秒）lockType：锁的类型，目前支持（可重入锁，公平锁，读写锁）。默认为：类名+方法名。
分布式锁注解@RedisLock,接口幂等性
CongBird的博客
02-08 1070
分布式锁的运用
基于Redis的分布式锁Klock的使用
Tenton的博客
08-10 1819
引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-klock-starter</artifactId> <version>1.4-release</version> </dependency> application.yml中配置 spring:
Redis之分布式锁
猎户星座
10-31 769
# 基于 Redis 实现分布式锁的三种方案 用 Redis 实现分布式锁的正确姿势（实现一） 用 Redisson 实现分布式可重入锁（RedissonLock）（实现二） 用 Redisson 实现分布式锁(红锁 RedissonRedLock)（实现三） 本文主要探讨基于 Redis 实现分布式锁的方案，主要分析并对比了以上三种方案，并大致分析了 Redisson 的 Redisson...
@RedisLock注解实现分布式锁
qq_33816292的博客
08-15 3651
@RedisLock注解实现分布式锁
redis分布式锁 做成注解 , 超好用 !
weixin_43786801的博客
09-24 816
redis分布式锁 做成注解
Redis分布式锁注解（Java实现）
weixin_47224121的博客
06-07 1841
在项目中遇到了插入重复数据的问题，为了防止并发造成重复数据的插入，故使用加锁，而传统的加锁是单机锁并不适用分布式项目，故采用Redis分布式锁。
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`注解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Whitemeen太白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值