public static DefaultFuture newFuture(Channel channel, Request request, int timeout, ExecutorService executor) {
    final DefaultFuture future = new DefaultFuture(channel, request, timeout);
    future.setExecutor(executor);
    // ThreadlessExecutor needs to hold the waiting future in case of circuit return.
    if (executor instanceof ThreadlessExecutor) {
        ((ThreadlessExecutor) executor).setWaitingFuture(future);
    }
    // 创建一个Future时候 进行timeout check 内部是创建一个基于时间轮的定时check任务
    timeoutCheck(future);
    return future;
}

private static void timeoutCheck(DefaultFuture future) {
    // 超时时间的检查任务
    TimeoutCheckTask task = new TimeoutCheckTask(future.getId());
    future.timeoutCheckTask = TIME_OUT_TIMER.newTimeout(task, future.getTimeout(), TimeUnit.MILLISECONDS);
}


private static class TimeoutCheckTask implements TimerTask {

    private final Long requestID;

    TimeoutCheckTask(Long requestID) {
        this.requestID = requestID;
    }

    // 超时检查的逻辑
    @Override
    public void run(Timeout timeout) {
        // 根据requestId从Future缓存中获取future
        DefaultFuture future = DefaultFuture.getFuture(requestID);
        if (future == null || future.isDone()) {
            // 如果future正常返回 则说明没有超时
            return;
        }
        // 否则去响应一个超时
        if (future.getExecutor() != null) {
            future.getExecutor().execute(() -> notifyTimeout(future));
        } else {
            notifyTimeout(future);
        }
    }

    private void notifyTimeout(DefaultFuture future) {
        // create exception response.
        // 客户端在超时之后创建一个超时的返回
        Response timeoutResponse = new Response(future.getId());
        // set timeout status.
        // 根据future的isSent确定状态是客户端响应超时 还是 服务端响应超时
        timeoutResponse.setStatus(future.isSent() ? Response.SERVER_TIMEOUT : Response.CLIENT_TIMEOUT);
        timeoutResponse.setErrorMessage(future.getTimeoutMessage(true));
        // handle response.
        // 响应超时
        DefaultFuture.received(future.getChannel(), timeoutResponse, true);
    }
}

发起RPC调用 
    --> 客户端代理对象 
        --> 服务目录/负载均衡选择一个可执行的Invoker
            -->Invoker客户端Filter链 
                -->AsyncToSyncInvoker(路由请求) 
                    --> DubboInvoker(委托NettyClient发送请求) 
                        --> HeaderExchangeChannel.request(发送请求 创建一个DefaltFuture)
                            --> DefaultFuture创建 时会注册一个定时任务检测超时
                            --> channel.send 真正去发送请求

@Activate(group = CommonConstants.PROVIDER)
public class TimeoutFilter implements Filter, Filter.Listener {

    private static final Logger logger = LoggerFactory.getLogger(TimeoutFilter.class);

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        return invoker.invoke(invocation);
    }

    // 执行完Invoker.invoke之后的回调
    @Override
    public void onResponse(Result appResponse, Invoker<?> invoker, Invocation invocation) {
        // 拿到写在上下文中的timeout统计
        Object obj = RpcContext.getContext().get(TIME_COUNTDOWN_KEY);
        if (obj != null) {
            TimeoutCountDown countDown = (TimeoutCountDown) obj;
            if (countDown.isExpired()) {
                // 如果超时 结果调用clear()方法清除
                ((AppResponse) appResponse).clear(); // clear response in case of timeout.
                if (logger.isWarnEnabled()) {
                    // 打印warn日志
                    logger.warn("invoke timed out. method: " + invocation.getMethodName() + " arguments: " +
                            Arrays.toString(invocation.getArguments()) + " , url is " + invoker.getUrl() +
                            ", invoke elapsed " + countDown.elapsedMillis() + " ms.");
                }
            }
        }
    }

    @Override
    public void onError(Throwable t, Invoker<?> invoker, Invocation invocation) {

    }
}

public class RRateLimiterDemo {
    static {
        // 输出日志info级别
        LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
        List<Logger> loggerList = loggerContext.getLoggerList();
        loggerList.forEach(logger -> {
            logger.setLevel(Level.INFO);
        });
    }
    public static void main(String[] args) throws InterruptedException {
        Config config = new Config();
        config.useSingleServer()
                .setTimeout(1000000)
                .setAddress("redis://127.0.0.1:6379");

        RedissonClient redisson = Redisson.create(config);
        RRateLimiter rateLimiter = redisson.getRateLimiter("myRateLimiter");
        // 初始化
        // 最大流速 = 每1秒钟产生N个令牌
        boolean b1 = rateLimiter.trySetRate(RateType.OVERALL, 5, 1, RateIntervalUnit.SECONDS);
        if (b1) {
            System.out.println("限流器初始化完成");
        }

        int allThreadNum = 20;

        CountDownLatch latch = new CountDownLatch(allThreadNum);

        long startTime = System.currentTimeMillis();
        AtomicInteger fail = new AtomicInteger(0);
        for (int i = 0; i < allThreadNum; i++) {
            new Thread(() -> {
                boolean b = rateLimiter.tryAcquire(1);
                if (!b) {
                    System.out.println(Thread.currentThread().getName() + "被拒绝");
                    fail.incrementAndGet();
                }else {
                    System.out.println(Thread.currentThread().getName());
                }
                latch.countDown();
            }).start();
        }
        latch.await();
        System.out.println("Elapsed " + (System.currentTimeMillis() - startTime) + ", 被限流fail: " + fail.get());
        rateLimiter.delete();
        redisson.shutdown();

    }
}

private void tryAcquireAsync(long permits, RPromise<Boolean> promise, long timeoutInMillis) {
    long s = System.currentTimeMillis();
    RFuture<Long> future = tryAcquireAsync(RedisCommands.EVAL_LONG, permits);
    future.onComplete((delay, e) -> {
        if (e != null) {
            promise.tryFailure(e);
            return;
        }
        
        if (delay == null) {
            //delay就是lua返回的 还需要多久才会有令牌
            promise.trySuccess(true);
            return;
        }
        
        //没有手动设置超时时间的逻辑
        if (timeoutInMillis == -1) {
            //延迟delay时间后重新执行一次拿令牌的动作
            commandExecutor.getConnectionManager().getGroup().schedule(() -> {
                tryAcquireAsync(permits, promise, timeoutInMillis);
            }, delay, TimeUnit.MILLISECONDS);
            return;
        }
        
        //el 请求redis拿令牌的耗时
        long el = System.currentTimeMillis() - s;
        //如果设置了超时时间，那么应该减去拿令牌的耗时
        long remains = timeoutInMillis - el;
        if (remains <= 0) {
            //如果那令牌的时间比设置的超时时间还要大的话直接就false了
            promise.trySuccess(false);
            return;
        }
        //比如设置的的超时时间为1s，delay为1500ms，那么1s后告知失败
        if (remains < delay) {
            commandExecutor.getConnectionManager().getGroup().schedule(() -> {
                promise.trySuccess(false);
            }, remains, TimeUnit.MILLISECONDS);
        } else {
            long start = System.currentTimeMillis();
            commandExecutor.getConnectionManager().getGroup().schedule(() -> {
                //因为这里是异步的，所以真正再次拿令牌之前再检查一下过去了多久时间。如果过去的时间比设置的超时时∂间大的话，直接false
                long elapsed = System.currentTimeMillis() - start;
                if (remains <= elapsed) {
                    promise.trySuccess(false);
                    return;
                }
                //再次拿令牌
                tryAcquireAsync(permits, promise, remains - elapsed);
            }, delay, TimeUnit.MILLISECONDS);
        }
    });
}

class LRUCache {
    class EasyNode {
        Integer key;
        Integer value;
        EasyNode(Integer key, Integer value) {
            this.key = key;
            this.value = value;
        }
    }
    Map<Integer, EasyNode> map;
    LinkedList<EasyNode> cache;
    int cap;

    public LRUCache(int capacity) {
        map = new HashMap<>(capacity);
        cache = new LinkedList<>();
        this.cap = capacity;
    }
    
    public int get(int key) {
        // 如果key在map中不存在 返回-1
        if (!map.containsKey(key)) {
            return -1;
        }

        // 存在 则维护LRU中双向链表的逻辑
        EasyNode node = map.get(key);
        // 删除再添加到队尾
        cache.remove(node);
        cache.addLast(node);
        return node.value;

    }
    
    public void put(int key, int value) {
        // map中存在 则map更新 且将该节点放入队尾
        EasyNode node = new EasyNode(key, value);
        if (map.containsKey(key)) {
            cache.remove(map.get(key));
            cache.addLast(node);
            map.put(key, node);
        } else{
            // 判断是否需要淘汰
            if (cache.size() == cap) {
                // 进行缓存的淘汰
                EasyNode removeNode = cache.removeFirst();
                map.remove(removeNode.key);
            }
            // 再添加到map和队尾
            map.put(key, node);
            cache.addLast(node);
        }
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

/**
 * 简单实现双端链表
 */
public class DeLinkedList<Key, Value> {
    // 头和尾节点
    private DeListNode<Key, Value> head, tail;

    // 链表元素个数
    private int size;

    public int size() {return  size;}

    public DeLinkedList() {
        // 初始化一个 头尾巴节点 两个节点不会在真正使用中用到
        head = new DeListNode<>(null, null);
        tail = new DeListNode<>(null, null);
        // 首尾连接
        head.setNext(tail);
        tail.setPrev(head);
    }

    // 给尾巴加入新的节点
    public void addLast(DeListNode<Key, Value> node) {

        // 虚拟的尾巴
        DeListNode<Key, Value> dummyTail = tail;
        // 真实的尾节点
        DeListNode<Key, Value> trueTail = dummyTail.getPrev();

        // 加入的节点和真实尾巴节点链接
        trueTail.setNext(node);
        node.setPrev(trueTail);

        // 再链接上虚拟尾巴节点
        node.setNext(dummyTail);
        dummyTail.setPrev(node);
        size ++;
    }

    public String toString() {
        if (head.getNext() == tail) {
            return
                    "[]";
        } else {
            DeListNode current = head.getNext();
            StringBuffer sb = new StringBuffer();
            sb.append(" 旧 [");
            while (!current.equals(tail)) {
                sb.append(current.toString());
                current = current.getNext();
            }
            sb.append("] 新");
            return sb.toString();
        }
    }

    public void remove(DeListNode<Key, Value> node) {
        // 假设node 一定存在
        node.getPrev().setNext(node.getNext());
        node.getNext().setPrev(node.getPrev());
        size -- ;
    }

    // 队头移除元素
    public DeListNode<Key, Value> removeFirst() {
        // 没有元素不操作
        if (head.getNext() == tail) {
            return null;
        }

        DeListNode<Key, Value> trueHead = head.getNext();
        head.setNext(trueHead.getNext());
        trueHead.getNext().setPrev(head);
        size--;
        return trueHead;
    }
}

@Bean
  @ConditionalOnMissingBean
  public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    // 通过SqlSessionFactoryBean来实现 SqlSesionFactory的初始化
    SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    
    factory.setDataSource(dataSource);
    factory.setVfs(SpringBootVFS.class);
    if (StringUtils.hasText(this.properties.getConfigLocation())) {
      factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
    }
    // 给factory设置Mybatis的全局配置对象Configuration
    applyConfiguration(factory);
    if (this.properties.getConfigurationProperties() != null) {
      factory.setConfigurationProperties(this.properties.getConfigurationProperties());
    }
    if (!ObjectUtils.isEmpty(this.interceptors)) {
      factory.setPlugins(this.interceptors);
    }
    if (this.databaseIdProvider != null) {
      factory.setDatabaseIdProvider(this.databaseIdProvider);
    }
    if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
      factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
    }
    if (this.properties.getTypeAliasesSuperType() != null) {
      factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
    }
    if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }
    if (!ObjectUtils.isEmpty(this.typeHandlers)) {
      factory.setTypeHandlers(this.typeHandlers);
    }
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }
    Set<String> factoryPropertyNames = Stream
        .of(new BeanWrapperImpl(SqlSessionFactoryBean.class).getPropertyDescriptors()).map(PropertyDescriptor::getName)
        .collect(Collectors.toSet());
    Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
    if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
      // Need to mybatis-spring 2.0.2+
      factory.setScriptingLanguageDrivers(this.languageDrivers);
      if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
        defaultLanguageDriver = this.languageDrivers[0].getClass();
      }
    }
    if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
      // Need to mybatis-spring 2.0.2+
      factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
    }

    return factory.getObject();
  }

protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
    Configuration configuration;
    XMLConfigBuilder xmlConfigBuilder = null;
    if (this.configLocation != null) {
        // 创建XMLConfigBuilder对象，读取指定的配置文件
        xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(),
            null, this.configurationProperties);
        configuration = xmlConfigBuilder.getConfiguration();
    } else {
        // 其他方式初始化Configuration全局配置对象
    }
    // 初始化MyBatis的相关配置和对象，其中包括：
    // 扫描typeAliasesPackage配置指定的包，并为其中的类注册别名
    // 注册plugins集合中指定的插件
    // 扫描typeHandlersPackage指定的包，并注册其中的TypeHandler
    // 配置缓存、配置数据源、设置Environment等一系列操作
    // ...... 省略配置代码
    
    if (this.transactionFactory == null) {
        // 默认使用的事务工厂类
        this.transactionFactory = new SpringManagedTransactionFactory();
    }

    // 根据mapperLocations配置，加载Mapper.xml映射配置文件以及对应的Mapper接口
    for (Resource mapperLocation : this.mapperLocations) {
        XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(...);
        xmlMapperBuilder.parse();
    }
    // 最后根据前面创建的Configuration全局配置对象创建SqlSessionFactory对象
    return this.sqlSessionFactoryBuilder.build(configuration);
}

@Bean
  @ConditionalOnMissingBean
  public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    ExecutorType executorType = this.properties.getExecutorType();
    if (executorType != null) {
        // 返回SqlSessionTemplate bean 用于手写数据库的CRUD操作。
      return new SqlSessionTemplate(sqlSessionFactory, executorType);
    } else {
      return new SqlSessionTemplate(sqlSessionFactory);
    }
  }

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    if (this.processPropertyPlaceHolders) {
      processPropertyPlaceHolders();
    }

    ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
    scanner.setAddToConfig(this.addToConfig);
    scanner.setAnnotationClass(this.annotationClass);
    scanner.setMarkerInterface(this.markerInterface);
    scanner.setSqlSessionFactory(this.sqlSessionFactory);
    scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
    scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
    scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
    scanner.setResourceLoader(this.applicationContext);
    scanner.setBeanNameGenerator(this.nameGenerator);
    // 设置扫描的Bean都是MapperFactoryBean接口的子类
    scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
    if (StringUtils.hasText(lazyInitialization)) {
      scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
    }
    if (StringUtils.hasText(defaultScope)) {
      scanner.setDefaultScope(defaultScope);
    }
    scanner.registerFilters();
    // scan扫描@Mapper注解的接口 注册bean定义。
    scanner.scan(
        StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
  }s

@Override
 public T getObject() throws Exception {
 // getSqlSession.getMapper 会从全局唯一的配置对象中寻找接口类对应的Mapper代理 
   return getSqlSession().getMapper(this.mapperInterface);
 }s