Deep Dive into Sentinel’s Core Slot‑Chain Mechanism and Entry Process

Sentinel, Alibaba’s open‑source flow‑control platform, is widely used for overload protection and stability; this article introduces its core concepts and the slot mechanism that implements request limiting.

The entry point after calling SphU.entry("HelloWorld") is the method com.alibaba.csp.sentinel.CtSph#entryWithPriority. The method builds a responsibility chain of ProcessorSlot objects and executes it to enforce flow‑control rules.

private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args) throws BlockException {
    // build slot chain
    ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);
    if (chain == null) {
        return new CtEntry(resourceWrapper, null, context);
    }
    Entry e = new CtEntry(resourceWrapper, chain, context);
    try {
        chain.entry(context, resourceWrapper, null, count, prioritized, args);
    } catch (BlockException e1) {
        e.exit(count, args);
        throw e1;
    } catch (Throwable e1) {
        RecordLog.info("Sentinel unexpected exception", e1);
    }
    return e;
}

The chain is obtained via lookProcessChain, which retrieves or creates a slot chain from chainMap. If the map does not contain a chain for the given resource, a new one is built using SlotChainProvider.newSlotChain(), respecting the maximum size limit Constants.MAX_SLOT_CHAIN_SIZE (6000 resources).

ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {
    ProcessorSlotChain chain = chainMap.get(resourceWrapper);
    if (chain == null) {
        synchronized (LOCK) {
            chain = chainMap.get(resourceWrapper);
            if (chain == null) {
                if (chainMap.size() >= Constants.MAX_SLOT_CHAIN_SIZE) {
                    return null;
                }
                chain = SlotChainProvider.newSlotChain();
                Map<ResourceWrapper, ProcessorSlotChain> newMap = new HashMap<>(chainMap.size() + 1);
                newMap.putAll(chainMap);
                newMap.put(resourceWrapper, chain);
                chainMap = newMap;
            }
        }
    }
    return chain;
}

The newSlotChain method loads a SlotChainBuilder via SPI; if none is found, it falls back to DefaultSlotChainBuilder.

public static ProcessorSlotChain newSlotChain() {
    if (slotChainBuilder != null) {
        return slotChainBuilder.build();
    }
    slotChainBuilder = SpiLoader.loadFirstInstanceOrDefault(SlotChainBuilder.class, DefaultSlotChainBuilder.class);
    if (slotChainBuilder == null) {
        RecordLog.warn("[SlotChainProvider] Wrong state when resolving slot chain builder, using default");
        slotChainBuilder = new DefaultSlotChainBuilder();
    } else {
        RecordLog.info("[SlotChainProvider] Global slot chain builder resolved: " + slotChainBuilder.getClass().getCanonicalName());
    }
    return slotChainBuilder.build();
}

Several built‑in slots form the chain:

NodeSelectorSlot : collects resource call paths and stores them in a tree for flow‑control and degradation.

ClusterBuilderSlot : creates ClusterNode objects that hold statistics such as RT, QPS, thread count, and origin information.

LogSlot : writes block logs to sentinel‑block.log.

StatisticSlot : the core slot that records real‑time invocation metrics using a high‑performance sliding window ( LeapArray).

FlowSlot : evaluates flow‑control rules in a defined order (app‑specific, other, default).

AuthoritySlot : enforces black‑/white‑list based on origin.

DegradeSlot : triggers circuit‑breaking based on average response time and exception ratio.

SystemSlot : adjusts entry traffic according to overall system load, applicable only to EntryType.IN.

The slot chain is extensible via the SPI interface; developers can add custom slots and reorder them to provide additional functionality.

Overall, Sentinel’s design follows the responsibility‑chain pattern, offering strong extensibility but also introducing challenges such as thread‑safety and potential statistical inconsistencies.