高可用之限流-03-Semaphore 信号量做限流

限流系列

开源组件 rate-limit: 限流
高可用之限流-01-入门介绍
高可用之限流-02-如何计划限流框架
高可用之限流-03-Semaphore 信号量做限流
高可用之限流-04-fixed window 固定窗口
高可用之限流-05-slide window 滑动窗口
高可用之限流-06-slide window 滑动窗口 sentinel 源码
高可用之限流-07-token bucket 令牌桶算法
高可用之限流 08-leaky bucket漏桶算法
高可用之限流 09-guava RateLimiter 入门使用简介 & 源码分析
主流的限流方式

现在主要有以下几种限流方式：

• 信号量
  
• 计数器
  
• 滑动窗口
  
• 漏桶算法
  
• 令牌桶算法
  
• 分布式限流
  

信号量

信号量实际上就是限制系统的并发量，来达到限流的目标。
常见的用法是：创建Semaphore，指定permit的数量。
在方法开始时，调用 Semaphore.acquire() 或者 Semaphore.tryAcquire() 来获取permit，并在方法返回前，调用Semaphore.release()来返还permit。
焦点代码实现

1. public class LimitSemaphore extends LimitAdaptor {
3.     /**
4.      * 日志
5.      *
6.      * @since 0.0.5
7.      */
8.     private static final Log LOG = LogFactory.getLog(LimitSemaphore.class);
10.     /**
11.      * 信号量
12.      *
13.      * @since 0.0.5
14.      */
15.     private final Semaphore semaphore;
17.     /**
18.      * 构造器
19.      *
20.      * @param context 上下文
21.      * @since 0.0.5
22.      */
23.     public LimitSemaphore(final ILimitContext context) {
24.         this.semaphore = new Semaphore(context.count());
25.     }
27.     @Override
28.     public synchronized void acquire() {
29.         try {
30.             LOG.debug("[Limit] start acquire");
31.             this.semaphore.acquire(1);
32.             LOG.debug("[Limit] end acquire");
33.         } catch (InterruptedException e) {
34.             Thread.currentThread().interrupt();
35.             LOG.error("[Limit] semaphore meet ex: ", e);
36.         }
37.     }
39.     @Override
40.     public void release() {
41.         LOG.debug("[Limit] start release");
42.         this.semaphore.release(1);
43.         LOG.debug("[Limit] end release");
44.     }
46. }

复制代码

测试

我们限定每次只有一个线程可以执行焦点方法，如下：

1. public class LimitSemaphoreTest {
3.     private static final Log LOG = LogFactory.getLog(LimitSemaphoreTest.class);
5.     private static final ILimit LIMIT = LimitBs.newInstance(LimitSemaphore.class)
6.             .count(1)
7.             .build();
9.     static class LimitRunnable implements Runnable {
10.         @Override
11.         public void run() {
12.             for(int i = 0; i < 2; i++) {
13.                 try {
14.                     LIMIT.acquire();
15.                     LOG.info("{}-{}", Thread.currentThread().getName(), i);
16.                     TimeUnit.SECONDS.sleep(1);
17.                 } catch (InterruptedException e) {
18.                     e.printStackTrace();
19.                 } finally {
20.                     LIMIT.release();
21.                 }
22.             }
23.         }
24.     }
26.     public static void main(String[] args) {
27.         new Thread(new LimitRunnable()).start();
28.         new Thread(new LimitRunnable()).start();
29.     }
31. }

复制代码

• 日志输出
  

1. 13:35:37.501 [Thread-1] INFO  com.github.houbb.rate.limit.test.semaphore.LimitSemaphoreTest - Thread-1-0
2. 13:35:38.501 [Thread-2] INFO  com.github.houbb.rate.limit.test.semaphore.LimitSemaphoreTest - Thread-2-0
3. 13:35:39.502 [Thread-1] INFO  com.github.houbb.rate.limit.test.semaphore.LimitSemaphoreTest - Thread-1-1
4. 13:35:40.503 [Thread-2] INFO  com.github.houbb.rate.limit.test.semaphore.LimitSemaphoreTest - Thread-2-1

复制代码

可以看到每次只有一个线程可以执行方法。
小结

这种方法最为简单，但是存在很多问题。
并入并发量问题，好比控制的力度不够灵活细致等。
后续我们来看下其他的实现方式。
参考资料

限流技术总结

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。