Sentinel Flow‑Control Framework: Architecture, Sliding‑Window Implementation and Comparison with Hystrix

Introduction

Sentinel is a lightweight traffic‑control framework for distributed service architectures. It maintains system stability through traffic shaping, circuit breaking, and system‑load protection.

Created in 2012 at Alibaba, Sentinel became the basic component of all Alibaba micro‑services by 2017 and was open‑sourced in 2018.

Sentinel Ecosystem

Sentinel supports a wide range of scenarios such as flash‑sale traffic spikes, message peak‑shaving, cluster‑wide flow control, and real‑time circuit breaking of downstream services.

Key Features

Rich Application Scenarios : Handles Alibaba’s ten‑year double‑11 traffic core use‑cases.

Real‑time Monitoring : Provides per‑machine second‑level metrics and aggregated cluster views.

Broad Open‑Source Ecosystem : Offers out‑of‑the‑box integrations with Spring Cloud, Apache Dubbo, gRPC, Quarkus, and native implementations for Java, Go, C++.

Extensible SPI : Allows custom rule management and dynamic data‑source adapters.

Sliding‑Window Basics

The sliding window is defined by four parameters:

intervalLength : Total time span of the statistical interval.

windowLength : Width of each individual window.

count : Statistic value stored in a window.

startTime : Start timestamp of a window; the timeline is divided by windowLength .

Only a fixed‑size array of windows is kept in memory; the array size sampleCount satisfies sampleCount = intervalLength / windowLength .

Updating a Window

public WindowWrap<T> currentWindow(long timeMillis) {
  if (timeMillis < 0) { return null; }
  int idx = calculateTimeIdx(timeMillis);
  long windowStart = calculateWindowStart(timeMillis);
  while (true) {
    WindowWrap<T> old = array.get(idx);
    if (old == null) {
      WindowWrap<T> window = new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
      if (array.compareAndSet(idx, null, window)) { return window; }
      else { Thread.yield(); }
    } else if (windowStart == old.windowStart()) {
      return old;
    } else if (windowStart > old.windowStart()) {
      if (updateLock.tryLock()) {
        try { return resetWindowTo(old, windowStart); }
        finally { updateLock.unlock(); }
      } else { Thread.yield(); }
    } else {
      return new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
    }
  }
}

Calculating Index and Window Start

private int calculateTimeIdx(long timeMillis) {
  long timeId = timeMillis / windowLengthInMs;
  return (int)(timeId % array.length());
}
protected long calculateWindowStart(long timeMillis) {
  return timeMillis - timeMillis % windowLengthInMs;
}

Fetching Statistics

public List<T> values(long timeMillis) {
  if (timeMillis < 0) { return new ArrayList<T>(); }
  int size = array.length();
  List<T> result = new ArrayList<T>(size);
  for (int i = 0; i < size; i++) {
    WindowWrap<T> w = array.get(i);
    if (w == null || isWindowDeprecated(timeMillis, w)) { continue; }
    result.add(w.value());
  }
  return result;
}
public boolean isWindowDeprecated(long time, WindowWrap<T> w) {
  return time - w.windowStart() > intervalInMs;
}

Flow‑Control Architecture

Every resource in Sentinel is identified by a resourceName . Each call creates an Entry object (automatically via adapters, annotations, or explicit SphU API). An Entry builds a slot chain, where each slot has a specific responsibility:

NodeSelectorSlot : Collects resource call paths for tree‑structured flow limiting.

ClusterBuilderSlot : Stores runtime metrics (RT, QPS, thread count) for multidimensional limiting.

StatisticSlot : Records runtime monitoring data.

FlowSlot : Enforces flow‑control rules based on collected statistics.

AuthoritySlot : Performs black‑/white‑list access control.

DegradeSlot : Executes circuit‑breaking based on metrics.

SystemSlot : Limits total entry traffic using system‑level indicators (e.g., load1).

The StatisticSlot core uses LeapArray to maintain second‑level metrics such as QPS, RT, and thread count.

Core Classes

ArrayMetric : Exposes metric APIs while hiding the underlying LeapArray .

LeapArray : Implements the circular array of WindowWrap objects.

WindowWrap : Represents a single window (generic type T ).

MetricBucket : Holds the actual counters; its type is defined by MetricEvent .

Usage Scenarios

FlowRuleManager

Manages flow‑control rules and keeps per‑minute metrics using a 60‑slot LeapArray where each slot spans 1 second.

private static final ScheduledExecutorService SCHEDULER =
    Executors.newScheduledThreadPool(1, new NamedThreadFactory("sentinel-metrics-record-task", true));

TimeUtil

Provides millisecond‑level time retrieval; when the system is busy it falls back to a Sentinel‑maintained time, also using a 3‑slot LeapArray with 1‑second windows.

public TimeUtil() {
  this.statistics = new LeapArray
(3, 3000) { ... };
  this.currentTimeMillis = System.currentTimeMillis();
  Thread daemon = new Thread(this);
  daemon.setDaemon(true);
  daemon.setName("sentinel-time-tick-thread");
  daemon.start();
}

Business Flow‑Control Implementation

Uses a 2‑slot LeapArray with 500 ms windows to record PASS, BLOCK, and OCCUPIED_PASS counts.

Comparison with Hystrix

Hystrix’s HystrixRollingNumber also uses a sliding window, but it consists of 10 buckets (default 1 s each). Each bucket records success, failure, timeout, and rejection counts. Hystrix relies heavily on CAS for thread‑safe updates, while Sentinel combines CAS with lightweight locks for bucket reset.

Conclusion

The article presented Sentinel’s origin, its sliding‑window implementation based on the LeapArray data structure, and a technical comparison with Hystrix’s flow‑control mechanism.