public void foo() {
    Entry entry = null;
    try {
       entry = SphU.entry("abc");
       // resource that need protection
    } catch (BlockException blockException) {
        // when goes there, it is blocked
        // add blocked handle logic here
    } catch (Throwable bizException) {
        // business exception
        Tracer.trace(bizException);
    } finally {
        // ensure finally be executed
        if (entry != null){
            entry.exit();
        }
    }
 }

或者

public void foo() {
　　if (SphO.entry("abc")) {
　　try {
　　　　// business logic
　　} finally {
　　　　SphO.exit(); // must exit()
　　}
　　} else {
　　　　// failed to enter the protected resource.
　　}
}

public static ProcessorSlotChain newSlotChain() {
        if (builder != null) {
            return builder.build();
        }
　　　　　// 构建chainBuilder，具体说明见下面代码
        resolveSlotChainBuilder();

        if (builder == null) {
            RecordLog.warn("[SlotChainProvider] Wrong state when resolving slot chain builder, using default");
            builder = new DefaultSlotChainBuilder();
        }
        return builder.build();
    }

    private static void resolveSlotChainBuilder() {
        List<SlotChainBuilder> list = new ArrayList<SlotChainBuilder>();
        boolean hasOther = false;
　　　　　// java.util.ServiceLoader 方式扩展功能，这是jdk的，简称spi扩展，sentinel有很多地方用到这种扩展方式
　　　　　// 关于ServiceLoader扩展的详解不在这里讨论，后面有时间可以单独拎出来分析下
for (SlotChainBuilder builder : LOADER) {
            if (builder.getClass() != DefaultSlotChainBuilder.class) {
                hasOther = true;
                list.add(builder);
            }
        }
        if (hasOther) {
            builder = list.get(0);
        } else {
            // No custom builder, using default.
            builder = new DefaultSlotChainBuilder();
        }

        RecordLog.info("[SlotChainProvider] Global slot chain builder resolved: "
            + builder.getClass().getCanonicalName());
    }

ContextUtil.enter("entrance1", "appA");
  Entry nodeA = SphU.entry("nodeA");
  if (nodeA != null) {
      nodeA.exit();
  }
  ContextUtil.exit();

ContextUtil.enter("entrance1", "appA");
      Entry nodeA = SphU.entry("nodeA");
      if (nodeA != null) {
          nodeA.exit();
      }
      ContextUtil.exit();
  
      ContextUtil.enter("entrance2", "appA");
      nodeA = SphU.entry("nodeA");
      if (nodeA != null) {
          nodeA.exit();
      }
ContextUtil.exit();

ContextUtil.enter("entrance1", "appA");
      Entry nodeA = null;
      try {
            nodeA = SphU.entry("nodeA");
            Entry nodeB = null;
            try {
    　　　  　nodeB = SphU.entry("nodeB");
    　　　  　}finally {
    　　　  　　　if (nodeB != null) {
    　　　  　　　　　nodeB.exit();
    　　　  　　　}
    　　　  　}
      }finally {
        if (nodeA != null) {
            nodeA.exit();
　　　　}
      }
ContextUtil.exit(); 

// 根据当前时间戳计算当前窗口的索引
private int calculateTimeIdx(/*@Valid*/ long timeMillis) {
　　　　　// 索引从0开始，整除后得到的结果就是当前时间戳所在的窗口，实际上我们的窗口只有array长度的固定几个，
　　　　　// 可以想象一下这是在一个无限延长的虚拟时间线窗口，再对array的length取余数就得到了实际所在的窗口索引
        long timeId = timeMillis / windowLengthInMs;
        // Calculate current index so we can map the timestamp to the leap array.
        return (int)(timeId % array.length());
    }

    protected long calculateWindowStart(/*@Valid*/ long timeMillis) {
　　　　　// 计算虚拟窗口对应的开始时间，当前时间减去超出当前窗口的那一段时间就得到开始时间
        return timeMillis - timeMillis % windowLengthInMs;
    }

    /**
     * Get bucket item at provided timestamp.
     *
     * @param timeMillis a valid timestamp in milliseconds
     * @return current bucket item at provided timestamp if the time is valid; null if time is invalid
     */
    public WindowWrap<T> currentWindow(long timeMillis) {
        if (timeMillis < 0) {
            return null;
        }
　　　　　// 获取当前窗口索引
        int idx = calculateTimeIdx(timeMillis);
        // Calculate current bucket start time.
　　　　　// 获取窗口开始时间
        long windowStart = calculateWindowStart(timeMillis);

        /*
         * Get bucket item at given time from the array.
         *
         * (1) Bucket is absent, then just create a new bucket and CAS update to circular array.
         * (2) Bucket is up-to-date, then just return the bucket.
         * (3) Bucket is deprecated, then reset current bucket and clean all deprecated buckets.
         */
        while (true) {
            WindowWrap<T> old = array.get(idx);
　　　　　　　// 如果索引对应的窗口还没有创建就新建窗口对象
            if (old == null) {
                /*
                 *     B0       B1      B2    NULL      B4
                 * ||_______|_______|_______|_______|_______||___
                 * 200     400     600     800     1000    1200  timestamp
                 *                             ^
                 *                          time=888
                 *            bucket is empty, so create new and update
                 *
                 * If the old bucket is absent, then we create a new bucket at {@code windowStart},
                 * then try to update circular array via a CAS operation. Only one thread can
                 * succeed to update, while other threads yield its time slice.
                 */
                WindowWrap<T> window = new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
　　　　　　　　　// 原子操作，如果设置成功就返回，如果设置失败就让出cpu，等待再次被翻牌
                if (array.compareAndSet(idx, null, window)) {
                    // Successfully updated, return the created bucket.
                    return window;
                } else {
                    // Contention failed, the thread will yield its time slice to wait for bucket available.
                    Thread.yield();
                }
　　　　　　　// 如果当前窗口时间一致，说明当前窗口还未过期，就返回该窗口对象
            } else if (windowStart == old.windowStart()) {
                /*
                 *     B0       B1      B2     B3      B4
                 * ||_______|_______|_______|_______|_______||___
                 * 200     400     600     800     1000    1200  timestamp
                 *                             ^
                 *                          time=888
                 *            startTime of Bucket 3: 800, so it's up-to-date
                 *
                 * If current {@code windowStart} is equal to the start timestamp of old bucket,
                 * that means the time is within the bucket, so directly return the bucket.
                 */
                return old;
　　　　　　　// 如果窗口开始时间过期了，就重置当前窗口的开始时间为最新的时间
            } else if (windowStart > old.windowStart()) {
                /*
                 *   (old)
                 *             B0       B1      B2    NULL      B4
                 * |_______||_______|_______|_______|_______|_______||___
                 * ...    1200     1400    1600    1800    2000    2200  timestamp
                 *                              ^
                 *                           time=1676
                 *          startTime of Bucket 2: 400, deprecated, should be reset
                 *
                 * If the start timestamp of old bucket is behind provided time, that means
                 * the bucket is deprecated. We have to reset the bucket to current {@code windowStart}.
                 * Note that the reset and clean-up operations are hard to be atomic,
                 * so we need a update lock to guarantee the correctness of bucket update.
                 *
                 * The update lock is conditional (tiny scope) and will take effect only when
                 * bucket is deprecated, so in most cases it won't lead to performance loss.
                 */
                if (updateLock.tryLock()) {
                    try {
                        // Successfully get the update lock, now we reset the bucket.
                        return resetWindowTo(old, windowStart);
                    } finally {
                        updateLock.unlock();
                    }
                } else {
                    // Contention failed, the thread will yield its time slice to wait for bucket available.
                    Thread.yield();
                }
　　　　　　　// 正常情况下不会走这里，因为时间是往前走的
            } else if (windowStart < old.windowStart()) {
                // Should not go through here, as the provided time is already behind.
                return new WindowWrap<T>(windowLengthInMs, windowStart, newEmptyBucket(timeMillis));
            }
        }
    }