【sentinel】深入浅出之原理篇Context初始化&Ent

public static void main(String[] args) {
    try {
        Context context=ContextUtil.enter("context1");
        Entry entry=SphU.entry("HelloWorld");
        entry.exit();
        ContextUtil.exit();
    } catch (BlockException ex) {
        // 处理被流控的逻辑
        System.out.println("blocked!");
    }catch (Exception e){
        e.printStackTrace();
    }
}

Context的初始化:

protected static Context trueEnter(String name, String origin) {
    //从ThreadLocal中获取Context 若当前线程Context存在，则不用重新创建
    Context context = contextHolder.get();
    if (context == null) {
        Map<String, DefaultNode> localCacheNameMap = contextNameNodeMap;
        DefaultNode node = localCacheNameMap.get(name);
        if (node == null) {
            if (localCacheNameMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {
                setNullContext();
                return NULL_CONTEXT;
            } else {
                try {
                    LOCK.lock();
                    //获取Node节点，一个Context对应一个EntranceNode节点 double check
                    node = contextNameNodeMap.get(name);
                    if (node == null) {
                        if (contextNameNodeMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {
                            setNullContext();
                            return NULL_CONTEXT;
                        } else {
                            //初始化EntranceNode节点
                            node = new EntranceNode(new StringResourceWrapper(name, EntryType.IN), null);
                            //添加EntranceNode节点，作为入口节点
                            Constants.ROOT.addChild(node);
                            
                            Map<String, DefaultNode> newMap = new HashMap<>(contextNameNodeMap.size() + 1);
                            newMap.putAll(contextNameNodeMap);
                            newMap.put(name, node);
                            contextNameNodeMap = newMap;
                        }
                    }
                } finally {
                    LOCK.unlock();
                }
            }
        }
        //初始化Context，这里的Node为EntranceNode节点，且多个Context公用一个，name为ContextName，EntranceNode节点的name也为ContextName，保持一致。
![未命名文件 (14).png](https://img.haomeiwen.com/i3397380/bf371885760e364d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
        context = new Context(node, name);
        context.setOrigin(origin);
        contextHolder.set(context);
    }
    return context;
}

在 Context初始化过程中，首先会从threadLocal中获取当前线程是否有上下文，如果没有，则从缓存中根据ContextName获取EntranceNode，如果EntranceNode不存在，则创建EntranceNode，然后初始化Context。所以，一个线程对应一个Context，一个ContextName对应多个Context，一个ContextName共享一个EntranceNode。
画个图 :

Context与EntranceNode的关系
当有三个线程访问 helloWorld的Context,会初始化3个Context，但是这三个Context共同指向同一个EntranceNode。

SphU.entry() 的过程

private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args)
    throws BlockException {
    Context context = ContextUtil.getContext();
    if (context instanceof NullContext) {
        return new CtEntry(resourceWrapper, null, context);
    }
    //如果没有初始化Context，则初始化一个默认的Context
    if (context == null) {
        context = MyContextUtil.myEnter(Constants.CONTEXT_DEFAULT_NAME, "", resourceWrapper.getType());
    }

    //查找SlotChain 一个Resource对应一个Chain
    ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);
    if (chain == null) {
        return new CtEntry(resourceWrapper, null, context);
    }
    //创建一个Entry
    Entry e = new CtEntry(resourceWrapper, chain, context);
    //执行SlotChain
    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;
}

在获取Entry的过程中，首先会获取Context，如果Context不存在，则默认创建一个新的，然后根据 Resource获取SlotChain,这里SlotChain是根据Resource一一对应， resourceName相同则表明是一个Resource, 同时，一次请求会创建一个 Entry，一个Entry和一次请求一一对应。

ProcessorSlot<Object> lookProcessChain(ResourceWrapper resourceWrapper) {
    //通过resourceWrapper获取SlotChain
    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;
                }
                //初始化一个新的SlotChain
                chain = SlotChainProvider.newSlotChain();
                //保存这个Resource对应的chain
                Map<ResourceWrapper, ProcessorSlotChain> newMap = new HashMap<ResourceWrapper, ProcessorSlotChain>(
                    chainMap.size() + 1);
                newMap.putAll(chainMap);
                newMap.put(resourceWrapper, chain);
                chainMap = newMap;
            }
        }
    }
    return chain;
}

ResourceWrapper 重写了ToString和HashCode可以看出只要name相同，则认为是一个Resource。

public abstract class ResourceWrapper {
    protected String name;
    protected EntryType type = EntryType.OUT;
    public abstract String getName();
    public abstract String getShowName();
    @Override
    public int hashCode() {
        return getName().hashCode();
    }
    @Override
    public boolean equals(Object obj) {
        if (obj instanceof ResourceWrapper) {
            ResourceWrapper rw = (ResourceWrapper)obj;
            return rw.getName().equals(getName());
        }
        return false;
    }
}

所以，一个resource对应一个SlotChain，一个请求创建一个Entry

如下图: request与resource与entry-slotChain的关系.png