分布式锁RSemaphore介绍

最新推荐文章于 2025-07-10 17:13:06 发布
最新推荐文章于 2025-07-10 17:13:06 发布
阅读量3.1k 收藏 11
点赞数 3
CC 4.0 BY-SA版权
分类专栏： 后端 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41024459/article/details/120368215
本文介绍了一种基于Redis的分布式信号量锁——RSemaphore。该组件用于限制同时访问共享区域的线程数量，提供了多种获取和释放资源的方法，并通过示例展示了其用法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

一.简介

二.方法总结

三.方法详情

1.acquire()

2.acquire(int permits)

3.tryAcquire()

4.tryAcquire(int permits)

5.tryAcquire​(long waitTime, TimeUnit unit)

6.tryAcquire​(int permits, long waitTime, TimeUnit unit)

7.release()

8.release​(int permits)

9.availablePermits()

10.drainPermits()

11.trySetPermits​(int permits)

12.addPermits​(int permits)

四.使用示例

五.源码解析

1.semaphore.trySetPermits(3);

2.semaphore.acquire()

3.semaphore.release()

总结

一.简介

 RSemaphore基于 Redis 的Semaphore开发。使用RSemaphore获取资源的顺序是不可预测的，所以它是一种非公平锁。可以理解为分布式的信号量，它的作用是用来限制同时访问共享区域的线程数量。

二.方法总结

Modifier and TypeMethodDescription
voidacquire()获取1个permit.
voidacquire(int permits)获取定义数量的permits.
voidaddPermits(int permits)按定义的值增加或减少可用许可证的数量。
intavailablePermits()返回可用许可证的数量。
intdrainPermits()获取并返回所有立即可用的许可证。
voidrelease()释放1个permit.
voidrelease(int permits)释放定义数量的permits.
booleantryAcquire()尝试获取当前可用的许可证。
booleantryAcquire​(int permits)尝试获取定义数量的permits。
boolean​tryAcquire(int permits, long waitTime, TimeUnit unit)尝试获取定义数量的permits。如果获取不到，就一直等待，直到获取到指定数量的permits。最长等待waitTime时间。
boolean​tryAcquire(long waitTime, TimeUnit unit)尝试获取1个permit。如果获取不到，就一直等待，直到成功获取1个permit。最长等待waitTime时间。
booleantrySetPermits(int permits)尝试设置许可证数量。

三.方法详情

1.acquire()

void acquire() throws InterruptedException

获取1个permit。如果没有，会一直等待，直到获得1个permit。

抛出：

InterruptedException - 如果当前线程被中断

InterruptedException

2.acquire(int permits)

void acquire​(int permits) throws InterruptedException

获取定义数量的permits。如果没有，会一直等待，直到获得定义数量的permits。

参数：

permits - 获得许可的数量

抛出：

InterruptedException - 如果当前线程被中断

IllegalArgumentException- 如果permits是负数

3.tryAcquire()

boolean tryAcquire()

尝试获取当前可用的许可证。

返回：
如果成功获得许可证，返回true；否则返回 false

4.tryAcquire(int permits)

boolean tryAcquire​(int permits)

尝试获取定义数量的permits。

参数：

permits - 获得许可的数量

返回：

如果成功获得指定数量的许可证，返回true；否则返回false

5.tryAcquire​(long waitTime, TimeUnit unit)

boolean tryAcquire​(long waitTime, TimeUnit unit) throws InterruptedException

尝试获取1个permit。如果获取不到，就一直等待，直到成功获取1个permit。最长等待waitTime时间。

参数：

waitTime - 最长等待时间

unit - 时间单位

返回：

如果成功获得1个permit，返回true；否则返回false

抛出：

InterruptedException - 如果当前线程被中断

6.tryAcquire​(int permits, long waitTime, TimeUnit unit)

boolean tryAcquire​(int permits, long waitTime, TimeUnit unit) throws InterruptedException

尝试获取定义数量的permits。如果获取不到，就一直等待，直到获取到指定数量的permits。最长等待waitTime时间。

参数：

permits - 许可证数量

waitTime - 最长等待时间

unit - 时间单位

返回：

如果成功获得指定数量的许可证，返回true；否则返回false

抛出：

InterruptedException - 如果当前线程被中断

7.release()

void release()

释放1个permit。增加一个可用permit的数量。

8.release​(int permits)

void release​(int permits)

释放定义数量的permits。增加定义数量个的可用permit的数量。

9.availablePermits()

int availablePermits()

返回可用许可证的数量。

10.drainPermits()

int drainPermits()

获取并返回所有立即可用的许可证。

11.trySetPermits​(int permits)

boolean trySetPermits​(int permits)

尝试设置许可数量。

返回：

如果许可证数量设置成功返回true；如果许可证数量已经设置过，返回false。

12.addPermits​(int permits)

void addPermits (int permit)
按定义的值增加或减少可用许可的数量。

四.使用示例

//可以在使用前初始化，但它不是必需的
RSemaphore semaphore = redisson.getSemaphore("semaphore");
// 同时最多允许3个线程获取锁
semaphore.trySetPermits(3);

for(int i = 0; i < 10; i++) {
  new Thread(new Runnable() {

    @Override
    public void run() {
      try {
        System.out.println(new Date() + "：线程[" + Thread.currentThread().getName() + "]尝试获取Semaphore锁"); 
        semaphore.acquire();
        System.out.println(new Date() + "：线程[" + Thread.currentThread().getName() + "]成功获取到了Semaphore锁，开始工作"); 
        Thread.sleep(3000);  
        semaphore.release();
        System.out.println(new Date() + "：线程[" + Thread.currentThread().getName() + "]释放Semaphore锁"); 
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }).start();
}

五.源码解析

1.semaphore.trySetPermits(3);

public class RedissonSemaphore extends RedissonExpirable implements RSemaphore {
    @Override
    public boolean trySetPermits(int permits) {
        return get(trySetPermitsAsync(permits));
    }
    
    @Override
    public RFuture<Boolean> trySetPermitsAsync(int permits) {
        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                "local value = redis.call('get', KEYS[1]); " +
                "if (value == false or value == 0) then "
                    + "redis.call('set', KEYS[1], ARGV[1]); "
                    + "redis.call('publish', KEYS[2], ARGV[1]); "
                    + "return 1;"
                + "end;"
                + "return 0;",
                Arrays.<Object>asList(getName(), getChannelName()), permits);
    }
}

执行流程为：

  1. get semaphore，获取到semaphore信号量的当前的值
  2. 第一次数据为0， 然后使用set semaphore 3，将这个信号量同时能够允许获取锁的客户端的数量设置为3。（注意到，如果之前设置过了信号量，将无法再次设置，直接返回0。想要更改信号量总数可以使用addPermits方法）
  3. 然后redis发布一些消息，返回1

2.semaphore.acquire()

public class RedissonSemaphore extends RedissonExpirable implements RSemaphore {
    @Override
    public void acquire(int permits) throws InterruptedException {
        if (tryAcquire(permits)) {
            return;
        }

        RFuture<RedissonLockEntry> future = subscribe();
        commandExecutor.syncSubscription(future);
        try {
            while (true) {
                if (tryAcquire(permits)) {
                    return;
                }

                getEntry().getLatch().acquire(permits);
            }
        } finally {
            unsubscribe(future);
        }
//        get(acquireAsync(permits));
    }

    @Override
    public boolean tryAcquire(int permits) {
        return get(tryAcquireAsync(permits));
    }


    @Override
    public RFuture<Boolean> tryAcquireAsync() {
        return tryAcquireAsync(1);
    }
    
    @Override
    public RFuture<Boolean> tryAcquireAsync(int permits) {
        if (permits < 0) {
            throw new IllegalArgumentException("Permits amount can't be negative");
        }
        if (permits == 0) {
            return RedissonPromise.newSucceededFuture(true);
        }

        return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                  "local value = redis.call('get', KEYS[1]); " +
                  "if (value ~= false and tonumber(value) >= tonumber(ARGV[1])) then " +
                      "local val = redis.call('decrby', KEYS[1], ARGV[1]); " +
                      "return 1; " +
                  "end; " +
                  "return 0;",
                  Collections.<Object>singletonList(getName()), permits);
    }
}

执行流程为：

  1. get semaphore，获取到一个当前的值，比如说是3，3 > 1
  2. decrby semaphore 1，将信号量允许获取锁的客户端的数量递减1，变成2
  3. decrby semaphore 1
  4. decrby semaphore 1
  5. 执行3次加锁后，semaphore值为0

此时如果再来进行加锁则直接返回0，然后进入死循环去获取锁

3.semaphore.release()

public class RedissonSemaphore extends RedissonExpirable implements RSemaphore {
    @Override
    public void release(int permits) {
        get(releaseAsync(permits));
    }
    
    @Override
    public RFuture<Void> releaseAsync() {
        return releaseAsync(1);
    }
    
    @Override
    public RFuture<Void> releaseAsync(int permits) {
        if (permits < 0) {
            throw new IllegalArgumentException("Permits amount can't be negative");
        }
        if (permits == 0) {
            return RedissonPromise.newSucceededFuture(null);
        }

        return commandExecutor.evalWriteAsync(getName(), StringCodec.INSTANCE, RedisCommands.EVAL_VOID,
            "local value = redis.call('incrby', KEYS[1], ARGV[1]); " +
            "redis.call('publish', KEYS[2], value); ",
            Arrays.<Object>asList(getName(), getChannelName()), permits);
    }
}

release semaphore 1，每次一个客户端释放掉这个锁的话，就会将信号量的值累加1，信号量的值就不是0了。

总结

这个组件还是比较简单的，实现了分布式信号量锁。

附上github链接：分布式锁和同步器

Redisson 分布式锁 - RLock、RReadWriteLock、RSemaphore、RCountDownLatch（配置、使用、原理）
CYK_byte的博客
06-04 1530
目录前言Redisson 分布式锁环境配置1）版本说明2）依赖如下3）配置文件如下4）项目配置RLock1）使用方式2）加锁解释3）加锁时手动设置时间4）加锁时，到底要不要手动设置过期时间？（最佳实践）RReadWriteLock1）使用方式2）加锁原理RSemaphore1）使用方式2）信号原理RCountDownLatch1）使用方式2）原理解释前面讲过一篇 Redisson 分布式锁的底层原理，而这篇文章着重实战，因此对原理不清楚的，可以看看我之前的文章：http://t.csdnimg.cn/LU5
谷粒商城高级篇-缓存和分布式锁
weixin_53175511的博客
10-16 431
Spring 从 3.1 开始定义了 org.springframework.cache.Cache和 org.springframework.cache.CacheManager 接口来统一不同的缓存技术；并支持使用 JCache（JSR-107）注解简化我们开发；Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合；Cache 接 口 下 Spring 提 供 了 各 种 xxxCache 的 实 现；
redis面试（二十四）Semaphore锁实现
weixin_41011482的博客
08-27 623
redisson中semaphore锁的视线代码以及内部的lua原理
redis redisson 信号量示例（RSemaphore）
weixin_43931625的博客
11-25 4555
redisredisson信号量示例 作用：限制同时访问共享区域的线程数量 ********************************************** 相关接口 RSemaphore public interface RSemaphore extends RExpirable, RSemaphoreAsync { boolean try...
分布式信号量 Semaphore
qq_33732195的博客
12-12 1825
基于Redis的Redisson的分布式信号量（Semaphore）；Java对象RSemaphore采用了与 juc 包下 Semaphore相似的接口和用法。同时还提供了异步（Async）、反射式（Reactive）、RxJava2标准的接口。 模拟车库停车， 3个车位 //停车 @GetMapping("/park") @ResponseBody public String park() throws InterruptedException { // 在redis中存 pack = 3
8. 【Redisson源码】分布式信号量RSemaphore
weixiaohuai的博客
01-18 2209
基于Redis的Redisson的分布式信号量RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。
分布式系统中的利器：redis-semaphore
gitblog_00048的博客
06-16 318
分布式系统中的利器：redis-semaphore 项目介绍 在分布式系统中，资源竞争和并发控制是常见的问题。为了解决这些问题，redis-semaphore 项目应运而生。它是一个基于 Redis 的互斥锁（Mutex）和信号量（Semaphore）实现，专为分布式系统设计。通过使用 redis-semaphore，开发者可以轻松地在分布式环境中实现资源的锁定和并发控制，确保系统的稳定性和可靠性...
17、详解java线程同步工具Semaphore的使用
冯冬冬的博客
10-25 536
Semaphore是java并发包里面的一个工具类，我们限制可以访问某些资源的线程数目就可以使用Semaphore了。这篇文章将对Semaphore的概念和使用进行一个详解。 一、概念理解 官方是这样解释的： Semaphore用于限制可以访问某些资源（物理或逻辑的）的线程数目，他维护了一个许可证集合，有多少资源需要限制就维护多少许可证集合，假如这里有N个资源，那就对应于N个许可证，同一时刻也只...
【并发编程】Redisson 的分布式锁
大家好，我是敖云岚，一个沉迷代码的 “技术玩家”。擅长 Java、C++ 开发，对 MySQL、Redis、RabbitMQ 等技术也颇有研究。博客里既有硬核技术干货，也有诙谐幽默的编程日常分享。愿和你一起，笑着学技术，快乐敲代码！
05-11 1420
Redisson 是一个开源的用于操作 Redis 的 Java 框架。与 Jedis 和 Lettuce 等轻量级的 Redis 框架不同，它提供了更高级且功能丰富的 Redis 客户端。它提供了许多简化 Redis 操作的高级 API，并支持分布式对象、分布式锁、分布式集合等特性。Redisson 可以设置分布式锁的过期时间，从而避免锁一直被占用而导致的死锁问题。
SpringCloud系列 - 分布式锁（八）
最新发布
路漫漫其修远兮，吾将上下而求索
07-10 1026
本文系统探讨了分布式锁的应用场景与实现方案。首先通过库存扣减案例演示了并发安全问题，分析本地锁在事务内失效、集群环境失效等问题。随后提出解决方案：调整SQL语句实现原子操作或引入分布式锁。重点介绍了基于Redis的分布式锁实现，详细讲解Redisson的多种锁机制（公平锁、读写锁）及同步工具（信号量、闭锁）。文章还解答了分布式锁与本地锁的关系、是否需要结合数据库锁等常见问题。最后指出：跨JVM共享资源必须使用分布式锁，单实例内部竞争可酌情使用本地锁，需根据业务需求平衡性能与一致性。
分布式锁三种方案以及Redisson
javajy的博客
06-20 494
原理：通过主键或者唯一索性两者都是唯一的特性，如果多个服务器同时请求到数据库，数据库只会允许同一时间只有一个服务器的请求在对数据库进行操作，其他服务器的请求就需要进行阻塞等待或者进行自旋。可以理解为同一时间只有一个请求能够拿到锁，当方式执行完成过后，对锁进行释放过后，其他请求就可以拿到锁再对数据库进行操作，这样就避免了数据不安全问题。其实原理一致，都是采用一个唯一的标识进行判断是否加锁。
Redisson中RSemaphore的使用场景及例子
qq_40592590的博客
08-01 752
redisson
分布式同步、信号量
cxzhq2002的杂记
04-08 1985
分布试系统中经常出现多个进程请求访问同一临界资源的问题。       目前, 对临界区进行控制访问的方法主要有三种: 集中式算法、令牌环算法和分布式算法。集中式算法类似于单处理机上的信号量方法, 先在分布式系统中选出一个协调者, 由它负责临界区使用情况的登记与管理。令牌环算法在分布式系统中将各进程组织成一个逻辑环, 并在系统中设置象征权力的令牌作为进程能否进入临界区的标志。以此来实现进程互斥
信号灯RSemaphore在线程里的用处
World of iOs
10-29 968
<br />symbian 2008-04-01 22:20:57 阅读119 评论0   字号：大中小 订阅 <br />Symbian提供了活动对象和活动对象调度器来模拟多线程，但有些情况并不能达我们需要的效果。比如声音引擎使用活动对象的处理方法，有时会产生明显的延迟。解决声音引擎响应延迟的问题，开另一条线程是较合理的办法。可是新开的线程与主线程如何配合工作呢？<br />     Symbian提出了信号灯的概念。<br />     比如需要解决这样一个问题：A线程进行下一步工作时，需要B线程完成某
【分布式锁】05-使用Redisson中Semaphore和CountDownLatch原理
meser88的博客
05-10 2127
前言 前面已经写了Redisson大多的内容，我们再看看Redisson官网共有哪些组件： 剩下还有Semaphore和CountDownLatch两块，我们就趁热打铁，赶紧看看Redisson是如何实现的吧。 我们在JDK中都知道Semaphore和CountDownLatch两兄弟，这里就不多赘述，不了解的可以再回头看看。 Semaphore使用示例 先看下Semaphore原理图如下： 接着我们看下Redisson中使用的案例： RSemaphore semaphore .
Semaphore安全释放
Xp545945的博客
08-31 1277
Semaphore应该比较熟悉了，从学习操作系统时就听过了，可以控制并行线程的数量。常用的使用方法如下 public class Main { static Semaphore semaphore = new Semaphore(1); public static void doBusinessMethod(String str) { try { semaphore.acquire(1); businessMethod(s
Java 并发系列（二）——Semaphore源码分析
玖涯博客
12-28 483
Semaphore 通常叫它信号量, 可以用来控制同时访问特定资源的线程数量，也可以用来保持资源生产者和消费者之间的资源限制关系，通过协调各个线程，以保证合理的使用资源。Semaphore 具有公平和非公平两种模式，本文通过源码对 Semaphore 的实现做简单分析。
Java并发编程之Semaphore知识整理
拥抱大数据的专栏
01-21 266
限流神器
redisson中Semaphore的信号量介绍及其原理
爪哇人的博客
07-06 4555
Semaphore通常叫信号量，可以用来同时控制访问特定资源的线程数量，通过协调各个线程，保证合理的使用资源。// 获得一个permit//获得var1个permit//尝试获得permit//尝试获得var1个permit//尝试获得permit, 等待时间var1//尝试获得var1个permit, 等待时间var2//释放1个permit//释放var1个permit//信号量的permits数//清空permits//设置permits数。
redisson分布式锁使用
04-24
Redisson是一个基于Redis的分布式Java对象和服务库，它提供了一种分布式锁实现方式，可以用于设置分布式锁，避免多个线程同时修改同一个资源。你可以使用Redisson提供的RLock、RSemaphore、RCountDownLatch等分布式并发工具类，通过Redis实现分布式锁。使用Redisson分布式锁时，需要对锁的获取和释放进行严谨的控制，确保多个线程访问同一资源时，同一时间只有一个线程可以获取到锁，否则可能会导致数据的不一致。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值