typescript复制代码package com.lizba.redis.limit;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Response;

/**
 * <p>
 *     通过zset实现滑动窗口算法限流
 * </p>
 *
 * @Author: Liziba
 * @Date: 2021/9/6 18:11
 */
public class SimpleSlidingWindowByZSet {

    private Jedis jedis;

    public SimpleSlidingWindowByZSet(Jedis jedis) {
        this.jedis = jedis;
    }

    /**
     * 判断行为是否被允许
     *
     * @param userId        用户id
     * @param actionKey     行为key
     * @param period        限流周期
     * @param maxCount      最大请求次数（滑动窗口大小）
     * @return
     */
    public boolean isActionAllowed(String userId, String actionKey, int period, int maxCount) {
        String key = this.key(userId, actionKey);
        long ts = System.currentTimeMillis();
        Pipeline pipe = jedis.pipelined();
        pipe.multi();
        pipe.zadd(key, ts, String.valueOf(ts));
        // 移除滑动窗口之外的数据
        pipe.zremrangeByScore(key, 0, ts - (period * 1000));
        Response<Long> count = pipe.zcard(key);
        // 设置行为的过期时间，如果数据为冷数据，zset将会删除以此节省内存空间
        pipe.expire(key, period);
        pipe.exec();
        pipe.close();
        return count.get() <= maxCount;
    }


    /**
     * 限流key
     *
     * @param userId
     * @param actionKey
     * @return
     */
    public String key(String userId, String actionKey) {
        return String.format("limit:%s:%s", userId, actionKey);
    }

}

java复制代码package com.lizba.redis.limit;

import redis.clients.jedis.Jedis;

/**
 *
 * @Author: Liziba
 * @Date: 2021/9/6 20:10
 */
public class TestSimpleSlidingWindowByZSet {

    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.211.108", 6379);
        SimpleSlidingWindowByZSet slidingWindow = new SimpleSlidingWindowByZSet(jedis);
        for (int i = 1; i <= 15; i++) {
            boolean actionAllowed = slidingWindow.isActionAllowed("liziba", "view", 60, 5);

            System.out.println("第" + i +"次操作" + (actionAllowed ? "成功" : "失败"));
        }

        jedis.close();
    }

}

bash复制代码 TimeUnit.MILLISECONDS.sleep(1);

typescript复制代码package com.lizba.redis.limit;

import com.google.common.collect.ImmutableList;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Response;

/**
 * <p>
 *     通过zset实现滑动窗口算法限流
 * </p>
 *
 * @Author: Liziba
 * @Date: 2021/9/6 18:11
 */
public class SimpleSlidingWindowByZSet {

    private Jedis jedis;

    public SimpleSlidingWindowByZSet(Jedis jedis) {
        this.jedis = jedis;
    }

    /**
     * lua脚本限流
     *
     * @param userId
     * @param actionKey
     * @param period
     * @param maxCount
     * @return
     */
    public boolean isActionAllowedByLua(String userId, String actionKey, int period, int maxCount) {
        String luaScript = this.buildLuaScript();

        String key = key(userId, actionKey);
        long ts = System.currentTimeMillis();
        System.out.println(ts);
        ImmutableList<String> keys = ImmutableList.of(key);
        ImmutableList<String> args = ImmutableList.of(String.valueOf(ts),String.valueOf((ts - period * 1000)), String.valueOf(period));
        Number count = (Number) jedis.eval(luaScript, keys, args);

        return count != null && count.intValue() <= maxCount;
    }


    /**
     * 限流key
     *
     * @param userId
     * @param actionKey
     * @return
     */
    private String key(String userId, String actionKey) {
        return String.format("limit:%s:%s", userId, actionKey);
    }


    /**
     * 针对某个key使用lua脚本限流
     *
     * @return
     */
    private String buildLuaScript() {
        return "redis.call('ZADD', KEYS[1], tonumber(ARGV[1]), ARGV[1])" +
                "\nlocal c" +
                "\nc = redis.call('ZCARD', KEYS[1])" +
                "\nredis.call('ZREMRANGEBYSCORE', KEYS[1], 0, tonumber(ARGV[2]))" +
                "\nredis.call('EXPIRE', KEYS[1], tonumber(ARGV[3]))" +
                "\nreturn c;";

    }

}

rust复制代码
trait Double {
    fn double(&self) -> Self;
}



impl Double for i32 {
    fn double(&self) -> i32 {
        *self * 2
    }
}


fn main() {
    let x : i32 = 10.double();
    //输出 double类型的值为 20
    println!("double类型的值为 {}",x)
}

rust复制代码
trait Cook {
    fn start(&self);
}


trait Wash {
    fn start(&self);
}

struct Chef;

impl Cook for Chef {
    fn start(&self) {
        println!("开始烹饪！！");
    }
}

impl Wash for Chef {
    fn start(&self) {
        println!("开始刷碗！！");
    }
}



fn main() {
    let me = Chef;
    //输出 
    // 开始烹饪！！
    // 开始刷碗！！
    <Cook>::start(&me);
    <Chef as Wash>::start(&me);
}

rust复制代码
fn test<T : Debug>(x : T) {
   println!("this is {:?}.",x);
}


fn main() {
   /*
   this is "Test".
   this is 77.
   this is true.
   this is ['n', 'a', 's', 's'].
   */
   test("Test");
   test(77i32);
   test(true);
   test(['n','a','s','s']);
}

rust复制代码
fn main() {

    let a: [i32; 3] = [1,2,3];
    let b: [i32; 10] = [0; 10];

    //1 2 3
    for i in a {
        print!(" {}",i);
    }
    // 0 0 0 0 0 0 0 0 0 0
    for i in b {
        print!(" {}",i);
    }
}

rust复制代码fn main() {

    fn mut_arr(a : &mut [i32]) {
        a[2] = 5;
    }

    println!("size of &[i32; 3] : {:?}", std::mem::size_of::<&[i32; 3]>());
    println!("size of &[i32]  : {:?}", std::mem::size_of::<&[i32]>());

    let mut v : [i32; 3] = [1,2,3];
    {
        let s : &mut [i32; 3] = &mut v;
        mut_arr(s);
    }
    // 输出为：
    // size of &[i32; 3] : 8
    // size of &[i32]  : 16
    // [1, 2, 5]
    println!("{:?}",v);
}

rust复制代码fn example_slice(arr: &[i32]) {
    unsafe {
        let (v1, v2) : (usize,usize) = std::mem::transmute(arr);

        println!("Value1 is {:x}",v1);
        println!("Value2 is {:x}",v2);
    }
}

fn main() {

    let arr : [i32; 5] = [1,2,3,4,5];
    let addr : &[i32; 5] = &arr;
    println!("Address of arr is: {:p}",addr);
    // 输出为：
    // Address of arr is: 0x7ffee759f424
    // Value1 is 7ffee759f424
    // Value2 is 5
    example_slice(addr as &[i32]);
}

rust复制代码fn main() {

    let a = 1..7;
    
    // 1   2  3  4  5  6
    for i in a {
        print!("{:?}\t",i);
    }
}

java复制代码public class DefaultConditional implements Condition {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        logger.info("------> 进行 Conditional 判断 <-------");

        return false;
    }
}

java复制代码@Bean
@ConditionalOnBean(TestService.class)
public ConfigBean getConfigBean() {
    logger.info("------> 开始加载 ConditionalOnBean <-------");
    return new ConfigBean();
}

java复制代码private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {

  // Step 1 : 获取当前 Configuration 中 @Bean 的元数据信息
  ConfigurationClass configClass = beanMethod.getConfigurationClass();
  MethodMetadata metadata = beanMethod.getMetadata();
  String methodName = metadata.getMethodName();

  // 判断是否应该跳过当前 Bean
  if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
     configClass.skippedBeanMethods.add(methodName);
     return;
  }
  if (configClass.skippedBeanMethods.contains(methodName)) {
     return;
  }
}

java复制代码// C- ConditionEvaluator
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {

    // Step 1 : 如果当前 Bean 不包含 @Conditional , 则直接返回
   if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
      return false;
   }

    // Step 2 : 有2种 ConfigurationPhase 的类型 , 表示2种配置的阶段
    // PARSE_CONFIGURATION :Condition应该在解析@Configuration类时进行计算 , 如果此时条件不匹配，则不会添加@Configuration类
    // REGISTER_BEAN : 条件不会阻止@Configuration类被添加 , 在评估条件时，所有@Configuration类都将被解析
   if (phase == null) {
      if (metadata instanceof AnnotationMetadata &&
            ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
         return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
      }
      return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
   }

   // Step 3 : 获取所有的 Condition 对象
   List<Condition> conditions = new ArrayList<>();
   for (String[] conditionClasses : getConditionClasses(metadata)) {
      for (String conditionClass : conditionClasses) {
         Condition condition = getCondition(conditionClass, this.context.getClassLoader());
         conditions.add(condition);
      }
   }

   // Step 4 : 排序 
   AnnotationAwareOrderComparator.sort(conditions);

   for (Condition condition : conditions) {
      ConfigurationPhase requiredPhase = null;
      if (condition instanceof ConfigurationCondition) {
         requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
      }
      // Step 5 : 最终的 Condition 匹配过程
      if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
         return true;
      }
   }

   return false;
}

java复制代码private static class ConfigurationClassFilter {

   // 自动配置的元数据
   private final AutoConfigurationMetadata autoConfigurationMetadata;

   List<String> filter(List<String> configurations) {
      long startTime = System.nanoTime();
      
      // 此处为所有的 Confiturations 类
      String[] candidates = StringUtils.toStringArray(configurations);
      boolean skipped = false;
      
      // 此处包含 OnBeanCondition , OnClassCondition  ,OnWebApplicationCondition 三种
      for (AutoConfigurationImportFilter filter : this.filters) {
         // 获取是否 存在 match 匹配
         boolean[] match = filter.match(candidates, this.autoConfigurationMetadata);
         for (int i = 0; i < match.length; i++) {
            if (!match[i]) {
               candidates[i] = null;
               skipped = true;
            }
         }
      }
      if (!skipped) {
         return configurations;
      }
      
      // 如果不能跳过 , 记录当前 Confiturations 类
      List<String> result = new ArrayList<>(candidates.length);
      for (String candidate : candidates) {
         if (candidate != null) {
            result.add(candidate);
         }
      }
      return result;
   }

}

java复制代码public boolean[] match(String[] autoConfigurationClasses, AutoConfigurationMetadata autoConfigurationMetadata) {
   // Step 1 :  准备 Report 对象 , 用于记录
   ConditionEvaluationReport report = ConditionEvaluationReport.find(this.beanFactory);
   // Step 2 : 获取对应的所有的 Condition 方法
   ConditionOutcome[] outcomes = getOutcomes(autoConfigurationClasses, autoConfigurationMetadata);
   
   boolean[] match = new boolean[outcomes.length];
   for (int i = 0; i < outcomes.length; i++) {
   
      // 对match中的数组进行赋值,当outcomes对应下标的ConditionOutcome匹配时为true.其他情况,返回false
      match[i] = (outcomes[i] == null || outcomes[i].isMatch());
      if (!match[i] && outcomes[i] != null) {
          // 记录日志
         logOutcome(autoConfigurationClasses[i], outcomes[i]);
         if (report != null) {
            // 像 ConditionEvaluationReport # SortedMap 存放评估条件
            report.recordConditionEvaluation(autoConfigurationClasses[i], this, outcomes[i]);
         }
      }
   }
   return match;
}

java复制代码public final class ConditionEvaluationReport {

    //bean名称
    private static final String BEAN_NAME = "autoConfigurationReport";
    
    //创建一个父的条件匹配对象
    private static final AncestorsMatchedCondition ANCESTOR_CONDITION = new AncestorsMatchedCondition();
    
    //存放类名或方法名（key）,条件评估输出对象（value）
    private final SortedMap<String, ConditionAndOutcomes> outcomes = new TreeMap<>();
    
    //是否是原始条件匹配对象
    private boolean addedAncestorOutcomes;
    //父的条件评估报告对象
    private ConditionEvaluationReport parent;
    
    //记录已经从条件评估中排除的类名称
    private final List<String> exclusions = new ArrayList<>();
    //记录作为条件评估的候选类名称
    private final Set<String> unconditionalClasses = new HashSet<>();

}

java复制代码protected final ConditionOutcome[] getOutcomes(String[] autoConfigurationClasses,
      AutoConfigurationMetadata autoConfigurationMetadata) {
      
   // Step 1 : 初始化一个和处理类等容量的数组
   ConditionOutcome[] outcomes = new ConditionOutcome[autoConfigurationClasses.length];
   
   // Step 2 : 遍历所有的 autoConfigurationClasses
   for (int i = 0; i < outcomes.length; i++) {
      String autoConfigurationClass = autoConfigurationClasses[i];
      
      if (autoConfigurationClass != null) {
          
         Set<String> onBeanTypes = autoConfigurationMetadata.getSet(autoConfigurationClass, "ConditionalOnBean");
         // 判断是否存在 ConditionalOnBean 标注的方法
         outcomes[i] = getOutcome(onBeanTypes, ConditionalOnBean.class);
         
         // 判断是否需要输出 ConditionOutcome 
         if (outcomes[i] == null) {
            Set<String> onSingleCandidateTypes = autoConfigurationMetadata.getSet(autoConfigurationClass,
                  "ConditionalOnSingleCandidate");
            // 此处是返回是否要处理
            outcomes[i] = getOutcome(onSingleCandidateTypes, ConditionalOnSingleCandidate.class);
         }
      }
   }
   return outcomes;
}

java复制代码@Override
public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {

   // 获取注解对应的方法名或者类名
   String classOrMethodName = getClassOrMethodName(metadata);
   try {
   
      // 获取对应的条件匹配类 , 此处会判断 metadata instanceof , 有限判断是否为 ClassMetadata
      ConditionOutcome outcome = getMatchOutcome(context, metadata);
      
      // 很简单的打印日志 , Trace 级别
      logOutcome(classOrMethodName, outcome);
      
      // 记录结果 , 通过 ConditionEvaluationReport 和 recordEvaluation 方法实现
      recordEvaluation(context, classOrMethodName, outcome);
      
      // 返回是否成功匹配
      return outcome.isMatch();
   }
   catch (NoClassDefFoundError ex) {
      throw new IllegalStateException(......);
   }
   catch (RuntimeException ex) {
      throw new IllegalStateException("Error processing condition on " + getName(metadata), ex);
   }
}

java复制代码public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
   // Step 1 : 获取当前容器 ClassLoader  
   ClassLoader classLoader = context.getClassLoader();
   ConditionMessage matchMessage = ConditionMessage.empty();
   // Step 2 : 判断是否有 ConditionalOnClass 约束
   List<String> onClasses = getCandidates(metadata, ConditionalOnClass.class);
   if (onClasses != null) {
      // Step 2-1 : filter 过滤 , 判断是否缺失类 
      List<String> missing = filter(onClasses, ClassNameFilter.MISSING, classLoader);
      if (!missing.isEmpty()) {
         return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnClass.class)
               .didNotFind("required class", "required classes").items(Style.QUOTE, missing));
      }
      // Step 2-2 : 构建 matchMessage
      matchMessage = matchMessage.andCondition(ConditionalOnClass.class)
            .found("required class", "required classes")
            .items(Style.QUOTE, filter(onClasses, ClassNameFilter.PRESENT, classLoader));
   }
   
   // Step 3 : 同理 , 判断是否需要 MissClasses
   List<String> onMissingClasses = getCandidates(metadata, ConditionalOnMissingClass.class);
   if (onMissingClasses != null) {
      // .... 与 ConditionalOnClass 基本类似 ,此处省略
   }
   return ConditionOutcome.match(matchMessage);
}

java复制代码public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
   ConditionMessage matchMessage = ConditionMessage.empty();
   
   
   MergedAnnotations annotations = metadata.getAnnotations();
   
   if (annotations.isPresent(ConditionalOnBean.class)) {
      // Step 1 :获取 ConditionalOnBean 注解信息
      Spec<ConditionalOnBean> spec = new Spec<>(context, metadata, annotations, ConditionalOnBean.class);
      // Step 2 : 返回匹配结果
      // 其内部通过 getNamesOfBeansIgnoredByType , getBeanNamesForType 等方式判断类是否存在 
      MatchResult matchResult = getMatchingBeans(context, spec);
      if (!matchResult.isAllMatched()) {
         String reason = createOnBeanNoMatchReason(matchResult);
         return ConditionOutcome.noMatch(spec.message().because(reason));
      }
      matchMessage = spec.message(matchMessage).found("bean", "beans").items(Style.QUOTE,
            matchResult.getNamesOfAllMatches());
   }
   if (metadata.isAnnotated(ConditionalOnSingleCandidate.class.getName())) {
        //.....
   }
   if (metadata.isAnnotated(ConditionalOnMissingBean.class.getName())) {
        //.....
   }
   return ConditionOutcome.match(matchMessage);
}

java复制代码transient Object[] elementData;

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

java复制代码public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

java复制代码private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

java复制代码private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

java复制代码private static final int DEFAULT_CAPACITY = 10;

java复制代码ensureCapacityInternal(size + 1);  // Increments modCount!!

java复制代码private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

java复制代码private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

java复制代码int newCapacity = oldCapacity + (oldCapacity >> 1);

java复制代码private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

java复制代码private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

java复制代码private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

java复制代码private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

java复制代码private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

java复制代码public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.addAll(Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
}

java复制代码public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

java复制代码private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

java复制代码CountDownLatch countDownLatch = new CountDownLatch(2);

java复制代码public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}

java复制代码public void countDown() {
    sync.releaseShared(1);
}

java复制代码public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

java复制代码protected boolean tryReleaseShared(int releases) {
    // Decrement count; signal when transition to zero
    for (;;) {
        int c = getState();
        if (c == 0)
            return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

java复制代码private void doReleaseShared() {
    for (;;) {
      //获取头结点
        Node h = head;
        if (h != null && h != tail) {
          //获取head结点的等待状态
            int ws = h.waitStatus;
          //如果head结点的状态为SIGNAL, 表明后面有人在排队
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                  //直到CAS成功
                    continue;            
                //再去唤醒后继结点；在独占锁的时候有说明，这里就不多说了； 
              unparkSuccessor(h);
            }
          //如果head结点的状态为0, 表明此时后面没人在排队, 就只是将head状态修改为PROPAGATE
     	else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                 //直到CAS成功
                 continue;                
        }
        if (h == head)                   
            break;
    }
}

java复制代码public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

java复制代码public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

java复制代码protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

java复制代码private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

ini复制代码import hashlib
m = hashlib.md5()
m.update(b'123')
m.hexdigest()

#加密后结果 202cb962ac59075b964b07152d234b70

bash复制代码# Linux 查看当前操作系统的内核信息
uname -a
# 查看当前操作系统系统的版本信息
cat /proc/version

sql复制代码tar -zxvf redis-cell-v0.2.5-powerpc64-unknown-linux-gnu.tar.gz

lua复制代码43767:M 08 Sep 2021 21:39:39.643 # Module /usr/local/soft/Redis-Cell-0.3.0/libredis_cell.so failed to load: /lib64/libc.so.6: version `GLIBC_2.18' not found (required by /usr/local/soft/Redis-Cell-0.3.0/libredis_cell.so)
43767:M 08 Sep 2021 21:39:39.643 # Can't load module from /usr/local/soft/Redis-Cell-0.3.0/libredis_cell.so: server aborting

bash复制代码yum install gcc
wget http://ftp.gnu.org/gnu/glibc/glibc-2.18.tar.gz
tar zxf glibc-2.18.tar.gz 
cd glibc-2.18/
mkdir build
cd build/
../configure --prefix=/usr
make -j4
make install

scss复制代码CL.THROTTLE liziba  10  5 60 1
               ▲     ▲  ▲  ▲ ▲
               |     |  |  | └───── apply 1 token (default if omitted) (本次申请一个token)
               |     |  └──┴─────── 5 tokens / 60 seconds  (60秒添加5个token到令牌桶中)
               |     └───────────── 10 max_burst    (最大的突发请求，不是令牌桶的最大容量)
               └─────────────────── key "liziba" (限流key)

bash复制代码127.0.0.1:6379> cl.throttle liziba 10 5 60 1
1) (integer) 0                    # 当前请求是否被允许，0表示允许，1表示不允许
2) (integer) 11                    # 令牌桶的最大容量，令牌桶中令牌数的最大值
3) (integer) 10                  # 令牌桶中当前的令牌数
4) (integer) -1                    # 如果被拒绝，需要多长时间后在重试，如果当前被允许则为-1
5) (integer) 12                    # 多长时间后令牌桶中的令牌会满

xml复制代码<dependency>
  <groupId>io.lettuce</groupId>
  <artifactId>lettuce-core</artifactId>
  <version>5.3.4.RELEASE</version>
  <!--排除 netty 包冲突-->
  <exclusions>
    <exclusion>
      <groupId>io.netty</groupId>
      <artifactId>netty-buffer</artifactId>
    </exclusion>
    <exclusion>
      <groupId>io.netty</groupId>
      <artifactId>netty-common</artifactId>
    </exclusion>
    <exclusion>
      <groupId>io.netty</groupId>
      <artifactId>netty-codec</artifactId>
    </exclusion>
    <exclusion>
      <groupId>io.netty</groupId>
      <artifactId>netty-transport</artifactId>
    </exclusion>
  </exclusions>
</dependency>

java复制代码package com.lizba.redis.limit.tokenbucket;

import io.lettuce.core.dynamic.Commands;
import io.lettuce.core.dynamic.annotation.Command;

import java.util.List;

/**
 * <p>
 *      Redis命令接口定义
 * </p>
 *
 * @Author: Liziba
 * @Date: 2021/9/8 23:50
 */
public interface IRedisCommand extends Commands {


    /**
     * 定义限流方法
     *
     * @param key           限流key
     * @param maxBurst      最大的突发请求，桶容量等于maxBurst + 1
     * @param tokens        tokens 与 seconds 是组合参数，表示seconds秒内添加个tokens
     * @param seconds       tokens 与 seconds 是组合参数，表示seconds秒内添加个tokens
     * @param apply         当前申请的token数
     * @return
     */
    @Command("CL.THROTTLE ?0 ?1 ?2 ?3 ?4")
    List<Object> throttle(String key, long maxBurst, long tokens, long seconds, long apply);

}

java复制代码package com.lizba.redis.limit.tokenbucket;

import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.dynamic.RedisCommandFactory;

import java.util.List;

/**
 * <p>
 *      Redis-Cell令牌桶限流
 * </p>
 *
 * @Author: Liziba
 * @Date: 2021/9/8 23:47
 */
public class TokenBucketRateLimiter {

    private static final String SUCCESS = "0";
    private RedisClient client;
    private StatefulRedisConnection<String, String> connection;
    private IRedisCommand command;

    public TokenBucketRateLimiter(RedisClient client) {
        this.client = client;
        this.connection = client.connect();
        this.command = new RedisCommandFactory(connection).getCommands(IRedisCommand.class);
    }


    /**
     * 请是否被允许
     *
     * @param key
     * @param maxBurst
     * @param tokens
     * @param seconds
     * @param apply
     * @return
     */
    public boolean isActionAllowed(String key, long maxBurst, long tokens, long seconds, long apply) {
        List<Object> result = command.throttle(key, maxBurst, tokens, seconds, apply);
        if (result != null && result.size() > 0) {
            return SUCCESS.equals(result.get(0).toString());
        }
        return false;
    }

}

java复制代码package com.lizba.redis.limit.tokenbucket;

import io.lettuce.core.RedisClient;

/**
 * <p>
 *      测试令牌桶限流
 *      测试参数 cl.throttle liziba 10 5 60 1
 * </p>
 *
 * @Author: Liziba
 * @Date: 2021/9/9 0:02
 */
public class TestTokenBucketRateLimiter {

    public static void main(String[] args) {
        RedisClient client = RedisClient.create("redis://192.168.211.108:6379");
        TokenBucketRateLimiter limiter = new TokenBucketRateLimiter(client);
        // cl.throttle liziba 10 5 60 1
        for (int i = 1; i <= 15; i++) {
            boolean success = limiter.isActionAllowed("liziba", 10, 5, 60, 1);
            System.out.println("第" + i + "次请求" + (success ? "成功" : "失败"));
        }

    }

}

复制代码第0次请求成功
第1次请求成功
第2次请求成功
第3次请求成功
第4次请求成功
第5次请求成功
第6次请求成功
第7次请求成功
第8次请求成功
第9次请求成功
第10次请求成功
第11次请求成功
第14次请求失败
第15次请求失败
第14次请求失败
第15次请求失败

arduino复制代码public abstract class ServiceThread implements Runnable {

    /* 内部持有一个线程 */
    private Thread thread;
    /* 线程安全的boolean类型 */
    private final AtomicBoolean started = new AtomicBoolean(false);
    
    public void start() {
        /* started保证了线程只会被启动一次 */
        if (!started.compareAndSet(false, true)) {
            return;
        }
        stopped = false;
        /* getServiceName()抽象方法交由子类实现，用以获取线程名称 */
        this.thread = new Thread(this, getServiceName());
        this.thread.setDaemon(isDaemon);
        this.thread.start();
    }
    
}

scala复制代码public class PullMessageService extends ServiceThread {

    /* PullRequest队列 */
    private final LinkedBlockingQueue<PullRequest> pullRequestQueue 
        = new LinkedBlockingQueue<>();
    
    @Override
    public void run() {
        /* 每次拉取消息都要检测自身状态，改变stopped的状态可以停止拉取消息逻辑 */
        while (!this.isStopped()) {
            /* pullRequestQueue 队列为空会阻塞 */
            PullRequest pullRequest = this.pullRequestQueue.take();
            /* 进行消息拉取 */
            this.pullMessage(pullRequest);
        }
    }
}

scala复制代码public class PullMessageService extends ServiceThread {

    private final MQClientInstance mQClientFactory;
    
    public PullMessageService(MQClientInstance mQClientFactory) {
        this.mQClientFactory = mQClientFactory;
    }

    private void pullMessage(PullRequest pullRequest) {
        MQConsumerInner consumer = this.mQClientFactory
            .selectConsumer(pullRequest.getConsumerGroup());
        
        DefaultMQPushConsumerImpl impl = 
            (DefaultMQPushConsumerImpl) consumer;
            
        impl.pullMessage(pullRequest);
    }

}

java复制代码public class DefaultMQPushConsumerImpl implements MQConsumerInner {

    private MQClientInstance mQClientFactory;

    public synchronized void start() throws MQClientException {
        switch (this.serviceState) {
            case CREATE_JUST: {
                /* 初始化 MQClientInstance */
                mQClientFactory = MQClientManager.getInstance()
                    .getOrCreateMQClientInstance(this.defaultMQPushConsumer, this.rpcHook);
                mQClientFactory.registerConsumer(
                    this.defaultMQPushConsumer.getConsumerGroup(), this
                );
                /* 虽然每个Consumer都调用此方法，但只启动一次 */
                mQClientFactory.start()
            }
            default:
                break;
        }
    }

}

java复制代码public class MQClientInstance { 
    
    private final ConcurrentMap<String, MQConsumerInner> consumerTable 
        = new ConcurrentHashMap<>();
        
    public boolean registerConsumer(String group, MQConsumerInner consumer) {
        if (null == group || null == consumer) {
            return false;
        }

        MQConsumerInner prev = this.consumerTable
            .putIfAbsent(group, consumer);
        return true;
    }

}

java复制代码public class MQClientInstance {
   
    private final PullMessageService pullMessageService;
    
    public MQClientInstance(ClientConfig clientConfig, 
        int instanceIndex, String clientId, RPCHook rpcHook) {
        this.rebalanceService = new RebalanceService(this);
    }
    
   
    public void start() throws MQClientException {
        synchronized (this) {
            switch (this.serviceState) {
                case CREATE_JUST:
                    this.rebalanceService.start();
                    break;
                default:
                    break;
            }
        }
    }

}

scala复制代码public class PullMessageService extends ServiceThread {

    public void executePullRequestLater(PullRequest pullRequest, 
        long timeDelay) {
        if (!isStopped()) {
            this.scheduledExecutorService.schedule(
                () -> executePullRequestImmediately(pullRequest),
                timeDelay,
                TimeUnit.MILLISECONDS
            );
        }
    }

    public void executePullRequestImmediately(PullRequest pullRequest) {
        this.pullRequestQueue.put(pullRequest);  
    }
    
}

java复制代码private void executePullRequestLater(PullRequest pullRequest, 
    long timeDelay) {
    this.mQClientFactory.getPullMessageService()
        .executePullRequestLater(pullRequest, timeDelay);
}

public void executePullRequestImmediately(PullRequest pullRequest) {
    this.mQClientFactory.getPullMessageService()
        .executePullRequestImmediately(pullRequest);
}

java复制代码public void dispatchPullRequest(List<PullRequest> pullRequestList) {
    for (PullRequest pullRequest : pullRequestList) {
        this.defaultMQPushConsumerImpl
            .executePullRequestImmediately(pullRequest);
    }
}

arduino复制代码public class PullRequest {

    /* 消费组 */
    private String consumerGroup;

    /* 待拉取消费队列 */
    private MessageQueue messageQueue;

    /* 消息处理队列，从Broker拉取到的消息会存放至此队列，而后提交到消费者消费线程池 */
    private ProcessQueue processQueue;

    /* 下一次拉取的启始偏移量 */
    private long nextOffset;
    
}

java复制代码public class MessageQueue implements Comparable<MessageQueue>, 
    Serializable {

    private String topic;
    private String brokerName;
    private int queueId;
    
}

java复制代码public class ProcessQueue {

    /* 消息临时存储容器 TreeMap<消息在ConsumerQueue中的偏移量，消息实体> */
    private final TreeMap<Long, MessageExt> msgTreeMap = new TreeMap<>();
    /* ProcessQueue中消息数量 */
    private final AtomicLong msgCount = new AtomicLong();
    /* ProcessQueue消息占用内存总和 */
    private final AtomicLong msgSize = new AtomicLong();

}

json复制代码{
    "topic": "topic",
    "brokerName": "broker0",
    "queueId": 0
}

java复制代码public void pullMessage(PullRequest pullRequest) {
    /* 通过 pullRequest 获取到 processQueue */
    ProcessQueue processQueue = pullRequest.getProcessQueue();
    /**
     * 由于Consumer节点，或者Broker Queue数量变换，导致负载均衡结果变动
     * 有可能之前分布在此 Consumer 节点上的 Queue 会被分配到别处，
     * 此时该 Queue 对应的快照 processQueue，本节点无权消费，置于被丢弃状态
     */
    if (processQueue.isDropped()) {
        /* 
         * 这里是直接丢弃pullRequest
         * 除非下一次负载均衡将该队列又分配回来，否则请求再也没有循环流转的机会
         */
        return;
    }

    /* 检查当前Consumer运行状态是否ServiceState.RUNNING，不是则直接抛出异常 */
    try {
        this.makeSureStateOK();
    } catch(MQClientException e) {
        /* 放弃本次，默认延迟3s再次拉取，pullRequest又入队了 */
        executePullRequestLater(pullRequest, pullTimeDelayMillsWhenException);
        return;
    }
    
    /* 若当前消费者被挂起，则将拉取任务延迟1s放至 PullMessageService 的拉取队列中，结束本次拉取 */
    if (this.isPause()) {
        /* 同样pullRequest又入队了 */
        executePullRequestLater(pullRequest, PULL_TIME_DELAY_MILLS_WHEN_SUSPEND);
        return;
    }
}

java复制代码@Data
public class Org {
    
    @ApiModelProperty(value = "部门ID")
    private String orgId;

    @ApiModelProperty(value = "部门名称")
    private String orgName;

    @ApiModelProperty(value = "父部门ID")
    private String parentOrgId;
    
    // ... 还有其他字段如 org_path  org_level
}

java复制代码@Data
public class OrgTreeNode {
    private String id;
    private String label;
    private String parentId;
    private Boolean disabled;
    private String isLeaf;
    private String isHidden;
    private String orgPath;
    private String ownerUserIds;
    private String ownerUserNames;
    private int sortNo;
    private Object data;

    private List<OrgTreeNode> children;

    public void addChildren(OrgTreeNode orgTree) {
        if (children == null) {
            children = new ArrayList<>();
        }
        children.add(orgTree);
    }

    public void addChildrens(List<OrgTreeNode> orgTreeList) {
        if (children == null) {
            children = new ArrayList<>();
        }
        children.addAll(orgTreeList);
    }

}

java复制代码@Slf4j
public class OrgTreeMenuUtil {

    /*
     * 排序,根据order排序
     */
    public Comparator<OrgTreeNode> order() {
        return (o1, o2) -> {
            if (o1.getSortNo() != o2.getSortNo()) {
                return o1.getSortNo() - o2.getSortNo();
            }
            return 0;
        };
    }

    public List<OrgTreeNode> findTree(List<OrgTreeNode> allMenu, String rootNode) {
        List<OrgTreeNode> rootMenu = new ArrayList<>();
        try {
            // 根节点
            for (OrgTreeNode nav : allMenu) {
                // rootNode为根节点
                if (rootNode.equals(nav.getParentId())) {
                    rootMenu.add(nav);
                }
            }
            // 根据Menu类的order排序
            rootMenu.sort(order());
            // 为根菜单设置子菜单，getClild是递归调用的
            for (OrgTreeNode nav : rootMenu) {
                // 获取根节点下的所有子节点 使用getChild方法
                List<OrgTreeNode> childList = getChild(nav.getId(), allMenu);
                // 给根节点设置子节点
                nav.setChildren(childList);
            }
            // 输出构建好的菜单数据
            return rootMenu;
        } catch (Exception e) {
            log.error(e.getMessage());
            return Collections.emptyList();
        }
    }

    /**
     * 获取子节点
     * @param id 父节点id
     * @param allMenu 所有菜单列表
     * @return 每个根节点下，所有子菜单列表
     */
    public List<OrgTreeNode> getChild(String id,List<OrgTreeNode> allMenu){
        // 子菜单
        List<OrgTreeNode> childList = new ArrayList<OrgTreeNode>();
        for (OrgTreeNode nav : allMenu) {
            // 遍历所有节点，将所有菜单的父id与传过来的根节点的id比较
            // 相等说明：为该根节点的子节点。
            if (id.equals(nav.getParentId())){
                childList.add(nav);
            }
        }
        // 递归
        for (OrgTreeNode nav : childList) {
            nav.setChildren(getChild(nav.getId(), allMenu));
        }
        // 排序
        childList.sort(order()); 
        // 如果节点下没有子节点，返回一个空List（递归退出）
        if (CollectionUtils.isEmpty(childList)){
            return new ArrayList<OrgTreeNode>();
        }
        return childList;
    }
}

java复制代码@Data
public class Org {
    
    @ApiModelProperty(value = "部门ID")
    private String orgId;

    @ApiModelProperty(value = "部门名称")
    private String orgName;

    @ApiModelProperty(value = "父部门ID")
    private String orgParentId;
    
    @ApiModelProperty(value = "子部门集合")
    private List<Org> children;
    
    // ... 还有其他字段如 org_path  org_level
}

java复制代码@Slf4j
public class OrgTreeMenuUtil {
    
    /**
     * 生成组织树
     *
     * @param list 
     * @param root 根节点id
     * @return
     */
    public List<Org> getTree(List<Org> list, String root) {
        List<Org> orgList = new ArrayList<>();
        Map<String, Org> parentObjs = new HashMap<>();
        // 找出所有的一级菜单
        for (Org org : list) { 
            if (org.getOrgParentId().equals(root)) {
                orgList.add(org);
            }
            // 记录所有菜单的id及对应的实体
            parentObjs.put(org.getOrgId(), org);
        }
 
        // 把每个组织加到父组织的子集中
        for (Org org : list) {
            // 如果是一级菜单，不需要找它的父级
            if (org.getOrgParentId().equals(root)) {
                continue;
            }
            // 每个组织找到自己的直接父级，并加入到父级的子集中
            Org parentObj = parentObjs.get(org.getOrgParentId());

            // 如果还没有子组织集合，新建一个集合并添加子组织
            if (Objects.isNull(parentObj.getChildren())) {
                parentObj.setChildren(new ArrayList<>());
            }
            parentObj.getChildren().add(org);
        }
        return orgList;
        
    }
    
}

java复制代码@Data
public class OrgDropdownListRes {
    private String id;
    private String pId;
    private String isLeaf;
    private String value;
    private String title;
    private List<Person> persons;
}

java复制代码@Data
public class Person {
    private String id;
    private String username;
    private String password;
    private String orgId;
    private Integer gender;
}

java复制代码	    private List<OrgDropdownListRes> convertOrg(List<Org> orgList, List<Person> personList) {
        List<OrgDropdownListRes> resList = Lists.newArrayList();
        orgList.forEach(o -> {
            OrgDropdownListRes res = new OrgDropdownListRes();
            res.setId(o.getOrgId());
            res.setPId(o.getParentOrgId());
            res.setValue(o.getOrgId());
            res.setTitle(o.getOrgName());
            res.setIsLeaf(SysConstants.IS_LEAF_1.equals(o.getIsLeaf()));
            if (!CollectionUtils.isEmpty(personList)) {
                Map<String, List<Person>> stringListMap = personList.stream().collect(Collectors.groupingBy(Person::getOrgId));
                res.setPersons(stringListMap.getOrDefault(o.getOrgId(), Collections.emptyList()));
            }
            resList.add(res);
        });
        return resList;
    }

python复制代码import turtle
 
from random import random
from random import randint
 
 
def draw_petal(turtle_obj, flower):
    # 绘制掉落的花瓣
    for i in range(int(flower)):
        # 有正有负就可以让画笔往二个方向走
        x = flower - 4 * flower * random()
 
        # 花瓣整体宽度(-10, 10)
        y = 10 - 20 * random()
 
        # 提笔，向前y，左转90，走x，落笔
        turtle_obj.penup()
        turtle_obj.forward(y)
        turtle_obj.left(90)
        turtle_obj.forward(x)
        turtle_obj.pendown()
 
        # 珊瑚色
        turtle_obj.pencolor("lightcoral")
        # 画圆
        turtle_obj.circle(1)
 
        # 回到起点
        # 提笔，后退x，右转90,后退y，落笔
        turtle_obj.penup()
        turtle_obj.backward(x)
        turtle_obj.right(90)
        turtle_obj.backward(y)
        turtle_obj.pendown()
 
 
# 画树枝部分
def draw_tree(turtle_obj, branch, tree_color):
    # 设置一个最小分支长度
    min_branch = 4
 
    if branch > min_branch:
        if branch < 8:
            # 以0.5的概率，向左、右分支
            if randint(0, 1) == 0:
                # 左为白色
                turtle_obj.pencolor("snow")
            else:
                # 右为珊瑚色
                turtle_obj.pencolor("lightcoral")
            # 枝干
            turtle_obj.pensize(branch / 2)
        elif 8 <= branch <= 16:
            # 以0.33的概率，分为左、中、右分支
            if randint(0, 2) == 0:
                # 左为白色
                turtle_obj.pencolor("snow")
            else:
                # 中、右为珊瑚色
                turtle_obj.pencolor("lightcoral")
            # 树枝
            turtle_obj.pensize(branch / 4)
        else:
            # 褐色
            turtle_obj.pencolor(tree_color)
            # 细枝
            turtle_obj.pensize(branch / 10)
 
        # 最开始的树干长度
        turtle_obj.forward(branch)
 
        # 随机度数因子
        a = 1.5 * random()
        # 顺时针旋转随机角度（0～30度）
        turtle_obj.right(20 * a)
 
        # 随机长度因子
        b = 1.5 * random()
        # 往右画，直到画不动为止
        draw_tree(turtle_obj, branch - 10 * b, tree_color)
 
        # 左转随机角度
        turtle_obj.left(40 * a)
        # 往左画，直到画不动位置
        draw_tree(turtle_obj, branch - 10 * b, tree_color)
 
        # 右转一定角度
        turtle_obj.right(20 * a)
        # 提笔
        turtle_obj.penup()
 
        # 递归结束回到起点
        turtle_obj.backward(branch)
        turtle_obj.pendown()
 
 
def get_screen(width, height, color, speed):
    # 创建画幕
    screen_obj = turtle.Screen()
    # 画布大小：(width, height)，颜色：color
    screen_obj.screensize(width, height, bg=color)
    screen_obj.setup(1.0, 1.0)
    # speed倍加速
    screen_obj.tracer(speed)
 
    return screen_obj
 
# 绘制多棵树
def trees(tree_num):
    # 颜色
    color = ['brown', 'tan', 'black']
 
    for j in range(tree_num):
        # 树干颜色
        tree_color = color[randint(0, len(color) - 1)]
 
        # 画笔大小
        pensize = randint(2, 5)
        # 前进像素
        forward = ((-1) ** pensize) * pensize * randint(20, 50)
        # 后退像素
        if pensize <= 3:
            backward = ((-1) ** pensize) * (5 - pensize) * randint(10, 15)
        else:
            backward = pensize * randint(45, 50)
 
        # 创建画笔
        turtle_obj = turtle.Turtle()
        # 画笔粗细
        turtle_obj.pensize(pensize)
        # 提笔，向前forward，左转90，backward，落笔
        turtle_obj.penup()
        turtle_obj.forward(forward)
        turtle_obj.left(90)
        turtle_obj.backward(backward)
        turtle_obj.pendown()
        # 画笔颜色：褐色
        turtle_obj.pencolor(tree_color)
 
        # 枝干粗细
        branch = pensize * 15
        # 落花数
        flowers = branch
        # 第j棵树
        draw_tree(turtle_obj, branch, tree_color)
        # 花瓣
        draw_petal(turtle_obj, flowers)
 
 
if __name__ == '__main__':
 
    # 创建画幕
    my_screen_width = 800
    my_screen_height = 600
    my_screen_color = 'wheat'
    my_screen_speed = 5
    my_screen_obj = get_screen(my_screen_width, my_screen_height,
                               my_screen_color, my_screen_speed)
 
    # 樱花树
    # 棵数
    my_tree_num = 5
    trees(my_tree_num)
 
    # 点击关闭画布
    my_screen_obj.exitonclick()