Sentinel source code analysis Chapter 9 - core process - lookprocesschain finding resource processing chain

Source code analysis one lookProcessChain

• adopt chainMap obtain resource Corresponding chain
• Return directly if it exists
• SLOT_CHAIN Examples exceed 6000 Then return to null, No processing
• adopt SlotChainProvider structure chain
• Join in chainMap

ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {
    
    chainMap  cache resourceWrapper Corresponding Slot
    ProcessorSlotChain chain = chainMap.get(resourceWrapper);
    if (chain == null) {
    
        synchronized (LOCK) {
    
            chain = chainMap.get(resourceWrapper);
            if (chain == null) {
    
                 If the number of resources is too large, it directly returns null No current limiting treatment 
                if (chainMap.size() >= Constants.MAX_SLOT_CHAIN_SIZE) {
    
                    return null;
                }
                 Create a new ProcessorSlotChain
                chain = SlotChainProvider.newSlotChain();
                 Build new resource and processor chain pools 
                Map<ResourceWrapper, ProcessorSlotChain> newMap = new HashMap<ResourceWrapper, ProcessorSlotChain>(
                        chainMap.size() + 1);
                newMap.putAll(chainMap);
                newMap.put(resourceWrapper, chain);
                chainMap = newMap;
            }
        }
    }
    return chain;
}

Source code analysis one SlotChainProvider structure slotChain

• adopt spi Get the builder DefaultSlotChainBuilder

public final class SlotChainProvider {
    
    private static volatile SlotChainBuilder slotChainBuilder = null;

    public static ProcessorSlotChain newSlotChain() {
    
        step-1: slotChain When the builder exists, he builds 
        if (slotChainBuilder != null) {
    
            return slotChainBuilder.build();
        }
        
        step-2: spi==spi And the default is :DefaultSlotChainBuilder
        slotChainBuilder = SpiLoader.loadFirstInstanceOrDefault(SlotChainBuilder.class, DefaultSlotChainBuilder.class);

        step-3:  The default policy 
        if (slotChainBuilder == null) {
    
            slotChainBuilder = new DefaultSlotChainBuilder();
        } 
        return slotChainBuilder.build();
    }
}

Source code analysis one slotChainBuilder.build

• adopt spi load slotchain

public class DefaultSlotChainBuilder implements SlotChainBuilder {
    

    @Override
    public ProcessorSlotChain build() {
    
        ProcessorSlotChain chain = new DefaultProcessorSlotChain();

        // Note: the instances of ProcessorSlot should be different, since they are not stateless.
        List<ProcessorSlot> sortedSlotList = SpiLoader.loadPrototypeInstanceListSorted(ProcessorSlot.class);


        /** * *  One way linked list  * first end * DefaultProcessorSlotChain --> --> spi * spi result : *  structure node Trees  * com.alibaba.csp.sentinel.slots.nodeselector.NodeSelectorSlot *  structure clusterNode * com.alibaba.csp.sentinel.slots.clusterbuilder.ClusterBuilderSlot *  journal  * com.alibaba.csp.sentinel.slots.logger.LogSlot *  Statistics  * com.alibaba.csp.sentinel.slots.statistic.StatisticSlot *  to grant authorization   White list   The blacklist  * com.alibaba.csp.sentinel.slots.block.authority.AuthoritySlot *  System  * com.alibaba.csp.sentinel.slots.system.SystemSlot *  Current limiting  * com.alibaba.csp.sentinel.slots.block.flow.FlowSlot *  Downgrade  * com.alibaba.csp.sentinel.slots.block.degrade.DegradeSlot */
        for (ProcessorSlot slot : sortedSlotList) {
    
            if (!(slot instanceof AbstractLinkedProcessorSlot)) {
    
                RecordLog.warn("The ProcessorSlot(" + slot.getClass().getCanonicalName() + ") is not an instance of AbstractLinkedProcessorSlot, can't be added into ProcessorSlotChain");
                continue;
            }

            chain.addLast((AbstractLinkedProcessorSlot<?>) slot);
        }

        return chain;
    }
}

summary

• lookProcessChain adopt spi complete Slot Chain loading of
• slot The chain is responsible for the core work of current limiting
• slot An instance of each resource in the chain
• slot The number of chains cannot exceed 6000