Redis分布式锁简单实现

原创 于 2025-08-04 18:26:26 发布 · 274 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#分布式

什么是分布式锁？

像synchronized、ReentrantLock这些都是Jvm锁，可以确保在单个jvm中，多线程访问共享资源安全性，当多个线程访问共享资源的时候，用 synchronized、ReentrantLock 将共享资源包裹起来，可确保共享资源只能被串行访问。

Redis分布式锁实现

1. 引入redisson配置

<!-- redisson -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.20.1</version>
</dependency>

2. RedissonConfig

yaml配置

spring:
  redis:
    host: 127.0.0.1
    port: 6379
@Configuration
public class RedissonConfig {
    @Autowired
    private RedisProperties redisProperties;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
        .setAddress("redis://" + redisProperties.getHost() + ":" + redisProperties.getPort())
        .setPassword(redisProperties.getPassword())
        .setDatabase(redisProperties.getDatabase());
        return Redisson.create(config);
    }
}

3. 接口实现类



/**
 * 分布式锁工具类
 */
public interface DistributeLock {

    /**
     * 尝试获取分布式锁，获取到锁后执行 supplier.get() 方法，然后释放锁，返回执行的返回值；若无法获取锁，抛出异常
     * 获取锁的过程不会阻塞
     * 锁会自动续期
     *
     * @param lockKey  上锁的key
     * @param supplier 需要执行的业务
     * @return 执行的返回值
     */
    <T>  T tryLockRun(String lockKey, Supplier<T> supplier);

    /**
     * 尝试在指定的时间内获取分布式锁，获取到锁后执行 supplier.get() 方法，然后释放锁，返回执行的返回值；若无法获取锁，抛出异常；此方法最多阻塞时长由waitTime指定
     * 获取锁的过程会阻塞，阻塞时长由 waitTime 指定
     * 锁会自动续期
     *
     * @param lockKey  上锁的key
     * @param supplier 需要执行的业务
     * @param waitTime 获取锁等待时间，必须大于 0
     * @param unit     时间单位
     * @return 执行的返回值
     */
    <T>  T tryLockRun(String lockKey, Supplier<T> supplier, long waitTime, TimeUnit unit);

    /**
     * 尝试在指定的时间内获取分布式锁，获取到锁后执行 supplier.get() 方法，然后释放锁，返回执行的返回值；若无法获取锁，抛出异常；此方法最多阻塞时长由waitTime指定
     * 获取锁的过程会阻塞，阻塞时长由 waitTime 指定
     * 超过了 leaseTime，若锁还未释放，则自动释放
     *
     * @param lockKey   上锁的key
     * @param supplier  需要执行的业务
     * @param waitTime  获取锁等待时间，必须大于 0
     * @param leaseTime 锁持有时间（必须大于 0：超过了这个时间，若未主动释放，则会自动释放）
     * @param unit      时间单位
     * @return 执行的返回值
     */
    <T>  T tryLockRun(String lockKey, Supplier<T> supplier, long waitTime, long leaseTime, TimeUnit unit) ;

    /**
     * 此方法会一直等待，直到获取锁后，获取到锁后执行  supplier.get() 方法，然后释放锁
     * 获取锁的过程会阻塞，直到成功获取锁
     * 锁会自动续期
     *
     * @param lockKey  上锁的key
     * @param supplier 需要执行的业务
     * @return 执行的返回值
     */
    <T>  T lockRun(String lockKey, Supplier<T> supplier);

    /**
     * 此方法会一直等待，直到获取锁后，获取到锁后执行  supplier.get() 方法，然后释放锁
     * 获取锁的过程会阻塞，直到成功获取锁
     * 超过了 leaseTime，若锁还未释放，则自动释放
     *
     * @param lockKey   上锁的key
     * @param supplier  需要执行的业务
     * @param leaseTime 锁持有时间（必须大于 0：超过了这个时间，若未主动释放，则会自动释放）
     * @param unit      时间单位
     * @return 执行的返回值      
     */
    <T>  T lockRun(String lockKey, Supplier<T> supplier, long leaseTime, TimeUnit unit);
}




@Service
@Slf4j
@RequiredArgsConstructor
public class DistributeLockImpl implements DistributeLock {

    private final RedissonClient redissonClient;

    // 锁前缀--可以加载配置里用来区分不同的业务
    private static final String LOCK_KEY_PREFIX = "lock:";

    @Override
    public <T> T tryLockRun(String lockKey, Supplier<T> supplier) {
        Objects.requireNonNull( supplier, "Supplier cannot be null");
        Objects.requireNonNull(lockKey, "Lock key cannot be null");
        String redisKey = LOCK_KEY_PREFIX+lockKey;
        RLock lock = redissonClient.getLock(redisKey);
        boolean  flag = lock.tryLock();
        if (!flag) {
            throw new RuntimeException("获取锁失败,锁被占用");
        }
        try {
            //执行锁内逻辑代码
            return supplier.get();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public <T> T tryLockRun(String lockKey, Supplier<T> supplier, long waitTime, TimeUnit unit) {
        Objects.requireNonNull( supplier, "Supplier cannot be null");
        Objects.requireNonNull(lockKey, "Lock key cannot be null");
        if (waitTime < 0){
            throw new IllegalArgumentException("Wait time should ge 0");
        }
        String redisKey = LOCK_KEY_PREFIX+lockKey;
        RLock lock = redissonClient.getLock(redisKey);
        try {
            boolean  flag = lock.tryLock(waitTime,unit);
            if (!flag) {
                throw new RuntimeException("获取锁失败,锁被占用");
            }
            //执行锁内逻辑代码
            return supplier.get();
        } catch (Exception e){
            throw new RuntimeException("获取锁异常->{}",e);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public <T> T tryLockRun(String lockKey, Supplier<T> supplier, long waitTime, long leaseTime, TimeUnit unit)  {
        Objects.requireNonNull( supplier, "Supplier cannot be null");
        Objects.requireNonNull(lockKey, "Lock key cannot be null");
        if (waitTime < 0){
            throw new IllegalArgumentException("Wait time should ge 0");
        }
        if (leaseTime < 0){
            throw new IllegalArgumentException("Lease time should ge 0");
        }
        String redisKey = LOCK_KEY_PREFIX+lockKey;
        RLock lock = redissonClient.getLock(redisKey);
        try {
            boolean  flag = lock.tryLock(waitTime,leaseTime,unit);
            if (!flag) {
                throw new RuntimeException("获取锁失败,锁被占用");
            }
            //执行锁内逻辑代码
            return supplier.get();
        } catch (Exception e){
            throw new RuntimeException("获取锁异常->{}",e);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public <T> T lockRun(String lockKey, Supplier<T> supplier) {
        Objects.requireNonNull( supplier, "Supplier cannot be null");
        Objects.requireNonNull(lockKey, "Lock key cannot be null");
        String redisKey = LOCK_KEY_PREFIX+lockKey;
        RLock lock = redissonClient.getLock(redisKey);
        lock.lock();
        try {
            //执行锁内逻辑代码
            return supplier.get();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public <T> T lockRun(String lockKey, Supplier<T> supplier, long leaseTime, TimeUnit unit) {
        Objects.requireNonNull( supplier, "Supplier cannot be null");
        Objects.requireNonNull(lockKey, "Lock key cannot be null");
        if (leaseTime < 0){
            throw new IllegalArgumentException("Lease time should ge 0");
        }
        String redisKey = LOCK_KEY_PREFIX+lockKey;
        RLock lock = redissonClient.getLock(redisKey);
        lock.lock(leaseTime,unit);
        try {
            //执行锁内逻辑代码
            return supplier.get();
        } catch (Exception e){
            throw new RuntimeException("获取锁异常->{}",e);
        } finally {
            lock.unlock();
        }
    }
}

4. 使用方法

 this.distributeLock.lockRun("lock1", () -> {
      //执行业务逻辑 
            retren null;
    });

测试类

1. 测试1

@GetMapping("/tryLockRun")
public String tryLockRun() {
    long startTime = System.currentTimeMillis();
    boolean lockResult = this.distributeLock.tryLockRun("lock1", () -> {
        log.info("获取锁成功，执行业务");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return true;
    });

    log.info("耗时：{},{}", (System.currentTimeMillis() - startTime), lockResult ? "获取锁成功" : "获取锁失败");
    return lockResult ? "获取锁成功" : "获取锁失败";
}

第一次调用获取到锁，执行任务，其它线程抢占报错

2. 测试2

@GetMapping("/tryLockRunWaitTime")
public String tryLockRunWaitTime() {
    long startTime = System.currentTimeMillis();
    log.info("tryLockRunWaitTime start");

 
    boolean lockResult = this.distributeLock.tryLockRun("lock1", () -> {
        log.info("获取锁成功，执行业务");
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return true;
    }, 4, TimeUnit.SECONDS);

    log.info("耗时：{},{}", (System.currentTimeMillis() - startTime), lockResult ? "获取锁成功" : "获取锁失败");
    return lockResult ? "获取锁成功" : "获取锁失败";
}

3. 测试3

 @GetMapping("/lockRun")
    public String lockRun() {
        long startTime = System.currentTimeMillis();
        log.info("lockRun start");
        this.distributeLock.lockRun("lock1", () -> {
            log.info("获取锁成功，执行业务");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            return true;
        });
        log.info("获取锁成功,耗时：{}", (System.currentTimeMillis() - startTime));
        return "获取锁成功";
    }

it-shiyadi
关注
java实现redis分布式锁(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-07 438
java实现redis分布式锁(附完整源码)
Redis实现分布式锁
weixin_53622554的博客
01-03 2559
1. 为什么需要分布式锁？我们都知道，以上情况，，此时就2. 单机锁 & 分布式锁的定义：3. 分布式锁应该具备哪些条件？4. 分布式锁都有哪些主流的实现方案？分布式锁的核心是实现多线程之间互斥，而满足这一点的方式有很多，常见的有三种：补充：Zookeeper实现分布式锁的思路实现分布式锁的核心思路5. 如何用 Redis 实现分布式锁的？Redis本身可以被多个客户端访问，正好就是一个共享存储系统，可以用来保存分布式锁，而且Redis的读写性能高，可以应对高并发的锁操作场景。
Java基于redis实现分布式锁代码实例
08-19
主要介绍了Java基于redis实现分布式锁代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Redis分布式锁--java实现
Artisan_w
01-13 2897
在单体redis中通过SETNX + EXPIRE方式可以为多个JVM加一个分布式锁，但是由于操作的非原子性会导致并发问题，因此出现了几种原子性解决方法，包括SETNX+时间value、lua脚本和SET扩展命令的方式解决，但是，依然会出现事务还没完成时间就失效，产生了新一轮并发，因此，通过添加一个看门狗线程定期检查能够解决这个问题，对于一个Java开发来说有一个Redisson框架实际上封装了lua脚本来实现。 哨兵和主从模式下的分布式redis，介绍了Redlock的原理与其缺陷。
java redis 分布式_java实现Redis分布式锁
weixin_30118071的博客
02-16 623
网上到处都是分布式锁的代码，基本都是通过setNX 和 expire这两个不是原子操作，肯定会有问题，不乏好多人通过用setNX的value当做过期时间来弥补等等。但是好像都不太好，或者多少有点问题。从一个大神那里得来的代码1 packagecom.abc.def.util;23 importredis.clients.jedis.Jedis;45 importjava.util.Collecti...
java redis分布式锁_Java实现基于Redis的分布式锁
weixin_36380063的博客
02-16 163
packagecc.lixiaohui.lock;importjava.util.concurrent.TimeUnit;importredis.clients.jedis.Jedis;/****基于Redis的SETNX操作实现的分布式锁**获取锁时最好用lock(longtime,TimeUnitunit),以免网路问题而导致线程一直阻塞**SETNC操作参考资料***@a...
C#.net Redis分布式锁源码实现
02-27
2. 使用String类型：Redis中的String类型可以用于存储简单的键值对，这在实现分布式锁时非常有用。锁的键通常是一个全局唯一的标识，而值可以是一个过期时间或状态信息。 3. SET命令与NX和EX选项：为了获取锁，可以...
C#实操控制并发之Lock和Redis分布式锁
01-21
以下是一个简单的C# Redis分布式锁实现： ```csharp public bool TryAcquireLock(string lockKey, int lockTimeout) { var redis = ConnectionMultiplexer.Connect("localhost:6379"); var db = redis.Get...
redis分布式锁工具包，提供纯Java方式调用，支持传统Spring工程.zip
02-08
综上所述，这个压缩包提供的Redis分布式锁工具包为Java开发者提供了一种简单、高效的方法来解决分布式环境下的锁问题，特别适合于处理高并发的快应用和企业级应用。通过集成到Spring工程中，开发人员可以利用Redis的...
redis分布式锁工具类
09-26
现在很多项目单机版已经不满足了，分布式变得越受欢迎，同时也带来很多问题，分布式锁也变得没那么容易实现，分享一个redis分布式锁工具类，里面的加锁采用lua脚本（脚本比较简单，采用java代码实现，无须外部调用...
分布式锁特点、以及用python3实现redis分布式锁
热门推荐
数据知道的博客
04-21 2万+
以下是 Python3 实现 Redis 分布式锁的详细教程，包含代码示例、原理说明及最佳实践。
Java 使用redis实现分布式锁
最新发布
weixin_45410882的博客
09-30 5354
Java SpringCloud实现分布式锁 (jedis、jedis+lua、redisson)
java中使用Redis实现分布式锁
cz1803472613的博客
04-18 4148
目前很多大型的互联网公司后端都采用了分布式架构来支撑前端应用，其中服务拆分就是分布式的一种体现，既然服务拆分了，那么多个服务协调工作就会出现一些资源竞争的情况。比如多个服务对同一个表中的数据进行处理。容易出现类似多线程的不同步问题。多线程不同步我们一般通过代码中的锁来强制同步执行。但是对于这种多个服务的，这种本地锁久显得无能为力了。
Redis分布式锁Java代码实现
Als1521的博客
04-20 187
Redis分布式锁Java代码实现。
Redis分布式锁代码实现(Java)
zxyhj的博客
11-07 1131
【代码】Redis分布式锁代码实现(Java)
Java实现Redis分布式锁
星光的博客
09-03 619
就用模拟抢票来实现锁，先看看不加任何锁的情况。 以下是测试代码。 public class App { private static int count = 100; public static void main(String[] args) throws InterruptedException { TicketThread ticketThread = new TicketT...
java redis分布式锁_Redis分布式锁java版
weixin_39834154的博客
02-12 171
一、引入maven依赖redis.clientsjedis2.9.0org.springframework.dataspring-data-redis1.8.16.RELEASE二、spring-data-jedis命令封装private StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();public Objec...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值