真实的国产乱ⅩXXX66竹夫人,五月香六月婷婷激情综合,亚洲日本VA一区二区三区,亚洲精品一区二区三区麻豆

成都創(chuàng)新互聯(lián)網(wǎng)站制作重慶分公司

Alibaba中Sentinel骨架的示例分析

這篇文章主要介紹Alibaba中Sentinel骨架的示例分析，文中介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們一定要看完！

創(chuàng)新互聯(lián)專注于企業(yè)全網(wǎng)營銷推廣、網(wǎng)站重做改版、潼關網(wǎng)站定制設計、自適應品牌網(wǎng)站建設、H5場景定制、商城網(wǎng)站定制開發(fā)、集團公司官網(wǎng)建設、外貿(mào)網(wǎng)站建設、高端網(wǎng)站制作、響應式網(wǎng)頁設計等建站業(yè)務，價格優(yōu)惠性價比高，為潼關等各大城市提供網(wǎng)站開發(fā)制作服務。

Sentinel 的核心骨架，將不同的 Slot 按照順序串在一起（責任鏈模式），從而將不同的功能（限流、降級、系統(tǒng)保護）組合在一起。slot chain 其實可以分為兩部分：統(tǒng)計數(shù)據(jù)構(gòu)建部分（statistic）和判斷部分（rule checking）。核心結(jié)構(gòu)：

Alibaba中Sentinel骨架的示例分析

業(yè)務埋點示例

// 資源的唯一標識
String resourceName = "testSentinel";
Entry entry = null;
String retVal;
try {
    entry = SphU.entry(resourceName, EntryType.IN);
    // TODO 業(yè)務邏輯 
    retVal = "passed";
} catch (BlockException e) {
    // TODO 降級邏輯
    retVal = "blocked";
} catch (Exception e) {
    // 異常數(shù)統(tǒng)計埋點
    Tracer.trace(e);
    throw new RuntimeException(e);
} finally {
    if (entry != null) {
        entry.exit();
    }
}

這段代碼是Sentinel業(yè)務埋點示例，通過示例我們可以看出Sentinel對資源的控制入口是SphU.entry(resourceName, EntryType.IN);，源碼如下：

public static Entry entry(String name, EntryType type) throws BlockException {
    return Env.sph.entry(name, type, 1, OBJECTS0);
}

這里第一個參數(shù)是受保護資源的唯一名稱；第二個參數(shù)表示流量類型：

  • EntryType.IN：是指進入我們系統(tǒng)的入口流量，比如 http 請求或者是其他的 rpc 之類的請求，設置為IN主要是為了保護自己系統(tǒng)。

  • EntryType.OUT：是指我們系統(tǒng)調(diào)用其他第三方服務的出口流量，設置為OUT是為了保護第三方系統(tǒng)。

這段代碼沒什么邏輯，只是轉(zhuǎn)發(fā)了下，跟進源碼可以發(fā)現(xiàn)最終邏輯實在CtSph#entryWithPriority(ResourceWrapper, int, boolean, Object...)方法中。

Sentinel 骨架代碼

Sentinel的核心是資源，這里的資源可以是任何東西，服務，服務里的方法，甚至是一段代碼。而SphU.entry(resourceName);這段代碼的主要作用是 ：

  1. 定義一個Sentinel資源

  2. 檢驗資源所對應的規(guī)則是否生效

核心代碼如下：

private Entry entryWithPriority(ResourceWrapper resourceWrapper, int count, boolean prioritized, Object... args)
    throws BlockException {
    // 獲取當前線程上下文，Context是通過ThreadLocal維護，每一個Context都會有一個EntranceNode實例，它是dashboard【簇點鏈路】中的根節(jié)點，主要是用來區(qū)分調(diào)用鏈路的
    Context context = ContextUtil.getContext();
    if (context instanceof NullContext) {
        // 如果是 NullContext，表示 Context 個數(shù)超過了閾值，這個時候 Sentinel 不會應用規(guī)則，即不會觸發(fā)限流降級等規(guī)則，也不會觸發(fā)QPS等數(shù)據(jù)統(tǒng)計。
        // 閾值大小 =Constants.MAX_CONTEXT_NAME_SIZE = 2000，具體可以查看 ContextUtil#trueEnter。
        return new CtEntry(resourceWrapper, null, context);
    }

    if (context == null) {
        // 如果沒有設置上下文，即使用默認上下文，默認上下文的名稱是  sentinel_default_context
        context = InternalContextUtil.internalEnter(Constants.CONTEXT_DEFAULT_NAME);
    }

    if (!Constants.ON) {
        // Sentinel 的全局控制開關，一旦關閉則不進行任何檢查
        return new CtEntry(resourceWrapper, null, context);
    }

    // 通過Sentinel的官方文檔我們可以知道，Sentinel的核心功能是基于一系列的功能插槽來實現(xiàn)的，而組織這些功能插槽使用的是責任鏈模式。
    // 這里是通過資源（每個資源是唯一的），獲取第一個功能插，即該資源對應的規(guī)則入口。
    ProcessorSlot chain = lookProcessChain(resourceWrapper);

    /*
     * Means amount of resources (slot chain) exceeds {@link Constants.MAX_SLOT_CHAIN_SIZE},
     * so no rule checking will be done.
     */
    // 如果一個服務中，資源數(shù)量操過閾值（最大的插槽鏈），則返回null，即不會再應用規(guī)則，直接返回。
    // 閾值大小 = Constants.MAX_SLOT_CHAIN_SIZE = 6000
    if (chain == null) {
        return new CtEntry(resourceWrapper, null, context);
    }

    // 構(gòu)建Sentinel調(diào)用鏈入口
    Entry e = new CtEntry(resourceWrapper, chain, context);
    try {
        // 開始執(zhí)行插槽鏈，如果某個插槽匹配上了某個規(guī)則，如限流規(guī)則，就會拋出BlockException異常，這時表示請求被拒絕了。
        // 業(yè)務層面會去捕獲這個異常，然后做熔斷，降級操作。
        chain.entry(context, resourceWrapper, null, count, prioritized, args);
    } catch (BlockException e1) {
        e.exit(count, args);
        throw e1;
    } catch (Throwable e1) {
        // Sentinel內(nèi)部異常
        RecordLog.info("Sentinel unexpected exception", e1);
    }
    return e;
}
核心邏輯如下：
  1. 通過當前線程的上下文，獲取到當前線程的【簇點鏈路】入口。
  2. 判斷全局開關是否關閉。
  3. 通過唯一的資源標識獲取到對應的功能插槽鏈（ProcessorSlot）的第一個插槽。
  4. 構(gòu)建Sentinel調(diào)用鏈入口，并執(zhí)行調(diào)用鏈
  5. 如果拋出BlockException表示觸發(fā)了資源限制規(guī)則，需要進行熔斷降級。
這里有兩個需要注意的地方：
  1. 【簇點鏈路】入口Context的數(shù)量是有限制的，最大2000個，通常情況下，我們都不需要顯示設置 context，使用默認的就好了，這樣Context數(shù)量限制基本上不會觸發(fā)。
  2. SphU.entry(resourceName, EntryType.IN)，這里的資源的唯一標識resourceName也是有限制的，最大是6000。當Sentinel與 Servlet 的整合后，CommonFilter會將所有的對外接口定義成Sentinel的資源，資源名稱就是接口地址，所以要控制好服務接口數(shù)量。
Alibaba中Sentinel骨架的示例分析
ContextUtil#enter
ContextUtil#enter(String name, String origin)的主要作用就是創(chuàng)建當前線程的上下文Context，每個上下文會對應一個EntranceNode（入口節(jié)點）實例，通常情況下我們不需要顯示調(diào)用該方法。
  • name：上下文的唯一標識，也是入口節(jié)點的資源名稱。
  • orgin：表示來源，通常是服務消費者或調(diào)用者的應用名稱，當我們需要對不同來源的消費者或調(diào)用者進行限制時就會用到這個參數(shù)。
源碼如下：
public static Context enter(String name, String origin) {
    if (Constants.CONTEXT_DEFAULT_NAME.equals(name)) {
        throw new ContextNameDefineException(
            "The " + Constants.CONTEXT_DEFAULT_NAME + " can't be permit to defined!");
    }
    return trueEnter(name, origin);
}

protected static Context trueEnter(String name, String origin) {
    // 通過ThreadLocal獲取當前線程的上下文
    Context context = contextHolder.get();
    // 如果沒獲取到需要新創(chuàng)建一個上下文
    if (context == null) {
        Map localCacheNameMap = contextNameNodeMap;
        // 根據(jù)上下文名稱獲取入口節(jié)點
        DefaultNode node = localCacheNameMap.get(name);
        // 入口節(jié)點節(jié)點也為空需要新創(chuàng)建入口節(jié)點
        if (node == null) {
            // 判斷是否超過最大長度限制（樂觀鎖機制）
            if (localCacheNameMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {
                setNullContext();
                return NULL_CONTEXT;
            } else {
                try {
                    LOCK.lock();
                    // 雙重判斷
                    node = contextNameNodeMap.get(name);
                    if (node == null) {
                        if (contextNameNodeMap.size() > Constants.MAX_CONTEXT_NAME_SIZE) {
                            setNullContext();
                            return NULL_CONTEXT;
                        } else {
                            // 新建入口節(jié)點
                            node = new EntranceNode(new StringResourceWrapper(name, EntryType.IN), null);
                            // 將入口節(jié)點添加到全局根節(jié)點下（machine-root）
                            Constants.ROOT.addChild(node);
                            // 類似寫復制容器機制
                            Map newMap = new HashMap<>(contextNameNodeMap.size() + 1);
                            newMap.putAll(contextNameNodeMap);
                            newMap.put(name, node);
                            contextNameNodeMap = newMap;
                        }
                    }
                } finally {
                    LOCK.unlock();
                }
            }
        }
        context = new Context(node, name);
        context.setOrigin(origin);
        contextHolder.set(context);
    }

    return context;
}
如果我們再代碼中顯示調(diào)用這個方法：
ContextUtil.enter("context1", "service-1"); 
...
ContextUtil.exit();

ContextUtil.enter("context2", "service-1"); 
...
ContextUtil.exit();
那么會創(chuàng)建如下一個樹結(jié)構(gòu)圖：
Alibaba中Sentinel骨架的示例分析
這里有兩點需要注意：
  1. 也就是上面說的數(shù)量限制，2000。
  2. ContextUtil是通過ThreadLocal來維護當前線程的上下文的，所以當遇到異步線程時需要手動調(diào)用ContextUtil.runOnContext(context, f)方法來完成父線程和子線程的上下文切換。
文檔中的Demo：
public void someAsync() {
    try {
        AsyncEntry entry = SphU.asyncEntry(resourceName);

        // Asynchronous invocation.
        doAsync(userId, result -> {
            // 在異步回調(diào)中進行上下文變換，通過 AsyncEntry 的 getAsyncContext 方法獲取異步 Context
            ContextUtil.runOnContext(entry.getAsyncContext(), () -> {
                try {
                    // 此處嵌套正常的資源調(diào)用.
                    handleResult(result);
                } finally {
                    entry.exit();
                }
            });
        });
    } catch (BlockException ex) {
        // Request blocked.
        // Handle the exception (e.g. retry or fallback).
    }
}
lookProcessChain
Sentinel的核心功能是使用的是責任鏈模式實現(xiàn)，lookProcessChain(resourceWrapper)的主要作用就是用來構(gòu)造責任鏈，源碼如下：
ProcessorSlot lookProcessChain(ResourceWrapper resourceWrapper) {
    // 根據(jù)資源的唯一標識來做本地緩存
    ProcessorSlotChain chain = chainMap.get(resourceWrapper);
    if (chain == null) {
        synchronized (LOCK) {
            chain = chainMap.get(resourceWrapper);
            if (chain == null) {
                // 限制資源資對應調(diào)用鏈的總數(shù)，一個資源對應一條調(diào)用鏈
                if (chainMap.size() >= Constants.MAX_SLOT_CHAIN_SIZE) {
                    return null;
                }
                // 構(gòu)建一個新的插槽鏈
                chain = SlotChainProvider.newSlotChain();
                // 寫復制容器做法
                Map newMap = new HashMap(
                    chainMap.size() + 1);
                newMap.putAll(chainMap);
                newMap.put(resourceWrapper, chain);
                chainMap = newMap;
            }
        }
    }
    return chain;
}
進一步跟進方法會發(fā)現(xiàn)，責任鏈是由SlotChainBuilder#build()````去構(gòu)建的，默認實現(xiàn)類是DefaultSlotChainBuilder```，源碼如下：
public class DefaultSlotChainBuilder implements SlotChainBuilder {

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

        // 找到ProcessorSlot所有的實現(xiàn)類，并排序
        List sortedSlotList = SpiLoader.loadPrototypeInstanceListSorted(ProcessorSlot.class);
        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;
    }
}
老版本直接是硬編碼方式：
public class DefaultSlotChainBuilder implements SlotChainBuilder {

    @Override
    public ProcessorSlotChain build() {
        ProcessorSlotChain chain = new DefaultProcessorSlotChain();
        chain.addLast(new NodeSelectorSlot());
        chain.addLast(new ClusterBuilderSlot());
        chain.addLast(new LogSlot());
        chain.addLast(new StatisticSlot());
        chain.addLast(new AuthoritySlot());
        chain.addLast(new SystemSlot());
        chain.addLast(new FlowSlot());
        chain.addLast(new DegradeSlot());

        return chain;
    }
}
以下內(nèi)容來自文檔：
  • NodeSelectorSlot： 負責收集資源的路徑，并將這些資源的調(diào)用路徑，以樹狀結(jié)構(gòu)存儲起來，用于根據(jù)調(diào)用路徑來限流降級；
  • ClusterBuilderSlot： 則用于存儲資源的統(tǒng)計信息以及調(diào)用者信息，例如該資源的 RT, QPS, thread count 等等，這些信息將用作為多維度限流，降級的依據(jù)；
  • StatisticSlot： 則用于記錄、統(tǒng)計不同緯度的 runtime 指標監(jiān)控信息；
  • FlowSlot： 則用于根據(jù)預設的限流規(guī)則以及前面 slot 統(tǒng)計的狀態(tài)，來進行流量控制；
  • AuthoritySlot： 則根據(jù)配置的黑白名單和調(diào)用來源信息，來做黑白名單控制；
  • DegradeSlot： 則通過統(tǒng)計信息以及預設的規(guī)則，來做熔斷降級；
  • SystemSlot： 則通過系統(tǒng)的狀態(tài)，例如 load1 等，來控制總的入口流量；
以上是“Alibaba中Sentinel骨架的示例分析”這篇文章的所有內(nèi)容，感謝各位的閱讀！希望分享的內(nèi)容對大家有幫助，更多相關知識，歡迎關注創(chuàng)新互聯(lián)行業(yè)資訊頻道！
            
            
                        

            標題名稱：Alibaba中Sentinel骨架的示例分析            

            文章分享：http://weahome.cn/article/pgoohd.html
        
    






    

        

            
                
                
在線咨詢

            
        

    

    

        
微信咨詢

        

    

    

        
電話咨詢

        

            
028-86922220（工作日）

            
18980820575（7×24）

        

    

    

        

            
                
提交需求

            
        

    

    

        

            
                
返回頂部