Sentinel

简介

分布式系统流量控制框架
分布式系统会存在很多应用，应用之间调用链路很长。如果突发大流量访问，某个服务挂掉后，如果不进行流量控制，整个系统可能会出现服务雪崩。下游系统崩溃，会造成上游的系统级联崩溃，最终造成整个系统不可用。
官方文档 链接

sentinel 可以用来做什么？

  1. 流量控制，流量整形
  2. 熔断
  3. 应用监控优势

优势：
与 hystrix 相比，hystrix 已经不再维护，sentinel 社区活跃，支持各种场景，比如 feign, dubbo, grpc。入门很简单，代码零侵入实现限流和熔断。

功能

SpringCloud Sentinel - 图1

生态

SpringCloud Sentinel - 图2

使用 Demo

依赖，主pom 文件添加：

  1.  <dependency>
  2.     <groupId>com.alibaba.cloud</groupId>
  3.     <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  4.     <version>2.0.3.RELEASE</version>
  5.     <type>pom</type>
  6.     <scope>import</scope>
  7. </dependency>

service pom 添加：

  1. <!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-sentinel -->
  2. <dependency>
  3.     <groupId>com.alibaba.cloud</groupId>
  4.     <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
  5. </dependency>

配置文件

  1. spring.cloud.sentinel.enabled=true
  2. spring.cloud.sentinel.transport.dashboard=127.0.0.1:8080
  3. spring.cloud.sentinel.transport.port=8719
  4. spring.cloud.sentinel.transport.client-ip= 127.0.0.1
  5. spring.cloud.sentinel.transport.heartbeat-interval-ms=5000
  6. feign.sentinel.enabled=true

控制台 jar 包 : 链接
下载下来后，指定端口启动

  1. java -Dserver.port=9561 \
  2. -Dcsp.sentinel.dashboard.server=localhost:9561 \
  3. -jar target/sentinel-dashboard.jar

访问服务后，dashBoard 可以显示实时的请求，可以对对应的资源配置限流和熔断。
image.png
对某个接口配置熔断：
image.png

熔断效果：
image.png

原理

使用责任链模式，把限流，统计，熔断==等功能通过责任链串起来，主要做数据统计和各种判断。底层做统计的数据结构是时间滑动窗口
image.png
滑动窗口的实现：

  1. package com.alibaba.csp.sentinel.slots.statistic.base;
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.concurrent.atomic.AtomicReferenceArray;
  6. import java.util.concurrent.locks.ReentrantLock;
  8. import com.alibaba.csp.sentinel.util.AssertUtil;
  9. import com.alibaba.csp.sentinel.util.TimeUtil;
  11. /**
  12.  * <p>
  13.  * Basic data structure for statistic metrics in Sentinel.
  14.  * </p>
  15.  * <p>
  16.  * Leap array use sliding window algorithm to count data. Each bucket cover {@code windowLengthInMs} time span,
  17.  * and the total time span is {@link #intervalInMs}, so the total bucket amount is:
  18.  * {@code sampleCount = intervalInMs / windowLengthInMs}.
  19.  * </p>
  20.  *
  21.  * @param <T> type of statistic data
  22.  * @author jialiang.linjl
  23.  * @author Eric Zhao
  24.  * @author Carpenter Lee
  25.  */
  26. public abstract class LeapArray<T> {
  28.     protected int windowLengthInMs;
  29.     protected int sampleCount;
  30.     protected int intervalInMs;
  31.     private double intervalInSecond;
  33.     protected final AtomicReferenceArray<WindowWrap<T>> array;
  35.     /**
  36.      * The conditional (predicate) update lock is used only when current bucket is deprecated.
  37.      */
  38.     private final ReentrantLock updateLock = new ReentrantLock();
  40.     /**
  41.      * The total bucket count is: {@code sampleCount = intervalInMs / windowLengthInMs}.
  42.      *
  43.      * @param sampleCount  bucket count of the sliding window
  44.      * @param intervalInMs the total time interval of this {@link LeapArray} in milliseconds
  45.      */
  46.     public LeapArray(int sampleCount, int intervalInMs) {
  47.         AssertUtil.isTrue(sampleCount > 0, "bucket count is invalid: " + sampleCount);
  48.         AssertUtil.isTrue(intervalInMs > 0, "total time interval of the sliding window should be positive");
  49.         AssertUtil.isTrue(intervalInMs % sampleCount == 0, "time span needs to be evenly divided");
  51.         this.windowLengthInMs = intervalInMs / sampleCount;
  52.         this.intervalInMs = intervalInMs;
  53.         this.intervalInSecond = intervalInMs / 1000.0;
  54.         this.sampleCount = sampleCount;
  56.         this.array = new AtomicReferenceArray<>(sampleCount);
  57.     }
  59.     /**
  60.      * Get the bucket at current timestamp.
  61.      *
  62.      * @return the bucket at current timestamp
  63.      */
  64.     public WindowWrap<T> currentWindow() {
  65.         return currentWindow(TimeUtil.currentTimeMillis());
  66.     }
  68.     /**
  69.      * Create a new statistic value for bucket.
  70.      *
  71.      * @param timeMillis current time in milliseconds
  72.      * @return the new empty bucket
  73.      */
  74.     public abstract T newEmptyBucket(long timeMillis);
  76.     /**
  77.      * Reset given bucket to provided start time and reset the value.
  78.      *
  79.      * @param startTime  the start time of the bucket in milliseconds
  80.      * @param windowWrap current bucket
  81.      * @return new clean bucket at given start time
  82.      */
  83.     protected abstract WindowWrap<T> resetWindowTo(WindowWrap<T> windowWrap, long startTime);
  85.     private int calculateTimeIdx(/*@Valid*/ long timeMillis) {
  86.         long timeId = timeMillis / windowLengthInMs;
  87.         // Calculate current index so we can map the timestamp to the leap array.
  88.         return (int)(timeId % array.length());
  89.     }
  91.     protected long calculateWindowStart(/*@Valid*/ long timeMillis) {
  92.         return timeMillis - timeMillis % windowLengthInMs;
  93.     }
  95.     /**
  96.      * Get bucket item at provided timestamp.
  97.      *
  98.      * @param timeMillis a valid timestamp in milliseconds
  99.      * @return current bucket item at provided timestamp if the time is valid; null if time is invalid
  100.      */
  101.     public WindowWrap<T> currentWindow(long timeMillis) {
  102.         if (timeMillis < 0) {
  103.             return null;
  104.         }
  106.         int idx = calculateTimeIdx(timeMillis);
  107.         // Calculate current bucket start time.
  108.         long windowStart = calculateWindowStart(timeMillis);
  110.         /*
  111.          * Get bucket item at given time from the array.
  112.          *
  113.          * (1) Bucket is absent, then just create a new bucket and CAS update to circular array.
  114.          * (2) Bucket is up-to-date, then just return the bucket.
  115.          * (3) Bucket is deprecated, then reset current bucket and clean all deprecated buckets.
  116.          */
  117.         while (true) {
  118.             WindowWrap<T> old = array.get(idx);
  119.             if (old == null) {
  120.                 /*
  121.                  *     B0       B1      B2    NULL      B4
  122.                  * ||_______|_______|_______|_______|_______||___
  123.                  * 200     400     600     800     1000    1200  timestamp
  124.                  *                             ^
  125.                  *                          time=888
  126.                  *            bucket is empty, so create new and update
  127.                  *
  128.                  * If the old bucket is absent, then we create a new bucket at {@code windowStart},
  129.                  * then try to update circular array via a CAS operation. Only one thread can
  130.                  * succeed to update, while other threads yield its time slice.
  131.                  */
  132.                 WindowWrap<T> window = new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
  133.                 if (array.compareAndSet(idx, null, window)) {
  134.                     // Successfully updated, return the created bucket.
  135.                     return window;
  136.                 } else {
  137.                     // Contention failed, the thread will yield its time slice to wait for bucket available.
  138.                     Thread.yield();
  139.                 }
  140.             } else if (windowStart == old.windowStart()) {
  141.                 /*
  142.                  *     B0       B1      B2     B3      B4
  143.                  * ||_______|_______|_______|_______|_______||___
  144.                  * 200     400     600     800     1000    1200  timestamp
  145.                  *                             ^
  146.                  *                          time=888
  147.                  *            startTime of Bucket 3: 800, so it's up-to-date
  148.                  *
  149.                  * If current {@code windowStart} is equal to the start timestamp of old bucket,
  150.                  * that means the time is within the bucket, so directly return the bucket.
  151.                  */
  152.                 return old;
  153.             } else if (windowStart > old.windowStart()) {
  154.                 /*
  155.                  *   (old)
  156.                  *             B0       B1      B2    NULL      B4
  157.                  * |_______||_______|_______|_______|_______|_______||___
  158.                  * ...    1200     1400    1600    1800    2000    2200  timestamp
  159.                  *                              ^
  160.                  *                           time=1676
  161.                  *          startTime of Bucket 2: 400, deprecated, should be reset
  162.                  *
  163.                  * If the start timestamp of old bucket is behind provided time, that means
  164.                  * the bucket is deprecated. We have to reset the bucket to current {@code windowStart}.
  165.                  * Note that the reset and clean-up operations are hard to be atomic,
  166.                  * so we need a update lock to guarantee the correctness of bucket update.
  167.                  *
  168.                  * The update lock is conditional (tiny scope) and will take effect only when
  169.                  * bucket is deprecated, so in most cases it won't lead to performance loss.
  170.                  */
  171.                 if (updateLock.tryLock()) {
  172.                     try {
  173.                         // Successfully get the update lock, now we reset the bucket.
  174.                         return resetWindowTo(old, windowStart);
  175.                     } finally {
  176.                         updateLock.unlock();
  177.                     }
  178.                 } else {
  179.                     // Contention failed, the thread will yield its time slice to wait for bucket available.
  180.                     Thread.yield();
  181.                 }
  182.             } else if (windowStart < old.windowStart()) {
  183.                 // Should not go through here, as the provided time is already behind.
  184.                 return new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
  185.             }
  186.         }
  187.     }
  189.     /**
  190.      * Get the previous bucket item before provided timestamp.
  191.      *
  192.      * @param timeMillis a valid timestamp in milliseconds
  193.      * @return the previous bucket item before provided timestamp
  194.      */
  195.     public WindowWrap<T> getPreviousWindow(long timeMillis) {
  196.         if (timeMillis < 0) {
  197.             return null;
  198.         }
  199.         int idx = calculateTimeIdx(timeMillis - windowLengthInMs);
  200.         timeMillis = timeMillis - windowLengthInMs;
  201.         WindowWrap<T> wrap = array.get(idx);
  203.         if (wrap == null || isWindowDeprecated(wrap)) {
  204.             return null;
  205.         }
  207.         if (wrap.windowStart() + windowLengthInMs < (timeMillis)) {
  208.             return null;
  209.         }
  211.         return wrap;
  212.     }
  214.     /**
  215.      * Get the previous bucket item for current timestamp.
  216.      *
  217.      * @return the previous bucket item for current timestamp
  218.      */
  219.     public WindowWrap<T> getPreviousWindow() {
  220.         return getPreviousWindow(TimeUtil.currentTimeMillis());
  221.     }
  223.     /**
  224.      * Get statistic value from bucket for provided timestamp.
  225.      *
  226.      * @param timeMillis a valid timestamp in milliseconds
  227.      * @return the statistic value if bucket for provided timestamp is up-to-date; otherwise null
  228.      */
  229.     public T getWindowValue(long timeMillis) {
  230.         if (timeMillis < 0) {
  231.             return null;
  232.         }
  233.         int idx = calculateTimeIdx(timeMillis);
  235.         WindowWrap<T> bucket = array.get(idx);
  237.         if (bucket == null || !bucket.isTimeInWindow(timeMillis)) {
  238.             return null;
  239.         }
  241.         return bucket.value();
  242.     }
  244.     /**
  245.      * Check if a bucket is deprecated, which means that the bucket
  246.      * has been behind for at least an entire window time span.
  247.      *
  248.      * @param windowWrap a non-null bucket
  249.      * @return true if the bucket is deprecated; otherwise false
  250.      */
  251.     public boolean isWindowDeprecated(/*@NonNull*/ WindowWrap<T> windowWrap) {
  252.         return isWindowDeprecated(TimeUtil.currentTimeMillis(), windowWrap);
  253.     }
  255.     public boolean isWindowDeprecated(long time, WindowWrap<T> windowWrap) {
  256.         return time - windowWrap.windowStart() > intervalInMs;
  257.     }
  259.     /**
  260.      * Get valid bucket list for entire sliding window.
  261.      * The list will only contain "valid" buckets.
  262.      *
  263.      * @return valid bucket list for entire sliding window.
  264.      */
  265.     public List<WindowWrap<T>> list() {
  266.         return list(TimeUtil.currentTimeMillis());
  267.     }
  269.     public List<WindowWrap<T>> list(long validTime) {
  270.         int size = array.length();
  271.         List<WindowWrap<T>> result = new ArrayList<WindowWrap<T>>(size);
  273.         for (int i = 0; i < size; i++) {
  274.             WindowWrap<T> windowWrap = array.get(i);
  275.             if (windowWrap == null || isWindowDeprecated(validTime, windowWrap)) {
  276.                 continue;
  277.             }
  278.             result.add(windowWrap);
  279.         }
  281.         return result;
  282.     }
  284.     /**
  285.      * Get all buckets for entire sliding window including deprecated buckets.
  286.      *
  287.      * @return all buckets for entire sliding window
  288.      */
  289.     public List<WindowWrap<T>> listAll() {
  290.         int size = array.length();
  291.         List<WindowWrap<T>> result = new ArrayList<WindowWrap<T>>(size);
  293.         for (int i = 0; i < size; i++) {
  294.             WindowWrap<T> windowWrap = array.get(i);
  295.             if (windowWrap == null) {
  296.                 continue;
  297.             }
  298.             result.add(windowWrap);
  299.         }
  301.         return result;
  302.     }
  304.     /**
  305.      * Get aggregated value list for entire sliding window.
  306.      * The list will only contain value from "valid" buckets.
  307.      *
  308.      * @return aggregated value list for entire sliding window
  309.      */
  310.     public List<T> values() {
  311.         return values(TimeUtil.currentTimeMillis());
  312.     }
  314.     public List<T> values(long timeMillis) {
  315.         if (timeMillis < 0) {
  316.             return new ArrayList<T>();
  317.         }
  318.         int size = array.length();
  319.         List<T> result = new ArrayList<T>(size);
  321.         for (int i = 0; i < size; i++) {
  322.             WindowWrap<T> windowWrap = array.get(i);
  323.             if (windowWrap == null || isWindowDeprecated(timeMillis, windowWrap)) {
  324.                 continue;
  325.             }
  326.             result.add(windowWrap.value());
  327.         }
  328.         return result;
  329.     }
  331.     /**
  332.      * Get the valid "head" bucket of the sliding window for provided timestamp.
  333.      * Package-private for test.
  334.      *
  335.      * @param timeMillis a valid timestamp in milliseconds
  336.      * @return the "head" bucket if it exists and is valid; otherwise null
  337.      */
  338.     WindowWrap<T> getValidHead(long timeMillis) {
  339.         // Calculate index for expected head time.
  340.         int idx = calculateTimeIdx(timeMillis + windowLengthInMs);
  342.         WindowWrap<T> wrap = array.get(idx);
  343.         if (wrap == null || isWindowDeprecated(wrap)) {
  344.             return null;
  345.         }
  347.         return wrap;
  348.     }
  350.     /**
  351.      * Get the valid "head" bucket of the sliding window at current timestamp.
  352.      *
  353.      * @return the "head" bucket if it exists and is valid; otherwise null
  354.      */
  355.     public WindowWrap<T> getValidHead() {
  356.         return getValidHead(TimeUtil.currentTimeMillis());
  357.     }
  359.     /**
  360.      * Get sample count (total amount of buckets).
  361.      *
  362.      * @return sample count
  363.      */
  364.     public int getSampleCount() {
  365.         return sampleCount;
  366.     }
  368.     /**
  369.      * Get total interval length of the sliding window in milliseconds.
  370.      *
  371.      * @return interval in second
  372.      */
  373.     public int getIntervalInMs() {
  374.         return intervalInMs;
  375.     }
  377.     /**
  378.      * Get total interval length of the sliding window.
  379.      *
  380.      * @return interval in second
  381.      */
  382.     public double getIntervalInSecond() {
  383.         return intervalInSecond;
  384.     }
  386.     public void debug(long time) {
  387.         StringBuilder sb = new StringBuilder();
  388.         List<WindowWrap<T>> lists = list(time);
  389.         sb.append("Thread_").append(Thread.currentThread().getId()).append("_");
  390.         for (WindowWrap<T> window : lists) {
  391.             sb.append(window.windowStart()).append(":").append(window.value().toString());
  392.         }
  393.         System.out.println(sb.toString());
  394.     }
  396.     public long currentWaiting() {
  397.         // TODO: default method. Should remove this later.
  398.         return 0;
  399.     }
  401.     public void addWaiting(long time, int acquireCount) {
  402.         // Do nothing by default.
  403.         throw new UnsupportedOperationException();
  404.     }
  405. }