@Slf4j
 @Component
 public class IRequestFilter extends OncePerRequestFilter {
     @Resource
     private FastMap fastMap;
 ?
     @Override
     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
         String address = attributes != null ? attributes.getRequest().getRemoteAddr() : UUID.randomUUID().toString();
         if (Objects.equals(request.getMethod(), "GET")) {
             StringBuilder str = new StringBuilder();
             str.append(request.getRequestURI()).append("|")
                     .append(request.getRemotePort()).append("|")
                     .append(request.getLocalName()).append("|")
                     .append(address);
             String hex = DigestUtil.md5Hex(new String(str));
             log.info("請求的MD5值為:{}", hex);
             if (fastMap.containsKey(hex)) {
                 throw new IllegalStateException("請求重復，請稍后重試!");
             }
             fastMap.put(hex, 10 * 1000L);
             fastMap.expired(hex, 10 * 1000L, (key, val) -> System.out.println("map:" + fastMap + ",刪除的key:" + key + ",線程名:" + Thread.currentThread().getName()));
         }
         log.info("請求的 address:{}", address);
         chain.doFilter(request, response);
     }
 }

 @Component
 public class FastMap {
     /**
      * 按照時間順序保存了會過期key集合，為了實現(xiàn)快速刪除，結構：時間戳 -> key 列表
      */
     private final TreeMap<Long, List<String>> expireKeysMap = new TreeMap<>();
     /**
      * 保存會過期key的過期時間
      */
     private final Map<String, Long> keyExpireMap = new ConcurrentHashMap<>();
     /**
      * 保存鍵過期的回調函數(shù)
      */
     private final HashMap<String, ExpireCallback<String, Long>> keyExpireCallbackMap = new HashMap<>();
     private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
     /**
      * 數(shù)據(jù)寫鎖
      */
     private final Lock dataWriteLock = readWriteLock.writeLock();
     /**
      * 數(shù)據(jù)讀鎖
      */
     private final Lock dataReadLock = readWriteLock.readLock();
     private final ReentrantReadWriteLock expireKeysReadWriteLock = new ReentrantReadWriteLock();
     /**
      * 過期key寫鎖
      */
     private final Lock expireKeysWriteLock = expireKeysReadWriteLock.writeLock();
     /**
      * 過期key讀鎖
      */
     private final Lock expireKeysReadLock = expireKeysReadWriteLock.readLock();
     /**
      * 定時執(zhí)行服務(全局共享線程池)
      */
     private volatile ScheduledExecutorService scheduledExecutorService;
     /**
      * 100萬，1毫秒=100萬納秒
      */
     private static final int ONE_MILLION = 100_0000;
     /**
      * 構造器，enableExpire配置是否啟用過期，不啟用排序
      */
     public FastMap() {
         this.init();
     }
     /**
      * 初始化
      */
     private void init() {
         // 雙重校驗構造一個單例的scheduledExecutorService
         if (scheduledExecutorService == null) {
             synchronized (FastMap.class) {
                 if (scheduledExecutorService == null) {
                     // 啟用定時器，定時刪除過期key,1秒后啟動，定時1秒, 因為時間間隔計算基于nanoTime,比timer.schedule更靠譜
                     scheduledExecutorService = new ScheduledThreadPoolExecutor(1, runnable -> {
                         Thread thread = new Thread(runnable, "expireTask-" + UUID.randomUUID());
                         thread.setDaemon(true);
                         return thread;
                     });
                 }
             }
         }
     }
     public boolean containsKey(Object key) {
         dataReadLock.lock();
         try {
             return this.keyExpireMap.containsKey(key);
         } finally {
             dataReadLock.unlock();
         }
     }
     public Long put(String key, Long value) {
         dataWriteLock.lock();
         try {
             return this.keyExpireMap.put(key, value);
         } finally {
             dataWriteLock.unlock();
         }
     }
     public Long remove(Object key) {
         dataWriteLock.lock();
         try {
             return this.keyExpireMap.remove(key);
         } finally {
             dataWriteLock.unlock();
         }
     }
     public Long expired(String key, Long ms, ExpireCallback<String, Long> callback) {
         // 對過期數(shù)據(jù)寫上鎖
         expireKeysWriteLock.lock();
         try {
             // 使用nanoTime消除系統(tǒng)時間的影響，轉成毫秒存儲降低timeKey數(shù)量,過期時間精確到毫秒級別
             Long expireTime = (System.nanoTime() / ONE_MILLION + ms);
             this.keyExpireMap.put(key, expireTime);
             List<String> keys = this.expireKeysMap.get(expireTime);
             if (keys == null) {
                 keys = new ArrayList<>();
                 keys.add(key);
                 this.expireKeysMap.put(expireTime, keys);
             } else {
                 keys.add(key);
             }
             if (callback != null) {
                 // 設置的過期回調函數(shù)
                 this.keyExpireCallbackMap.put(key, callback);
             }
             // 使用延時服務調用清理key的函數(shù)，可以及時調用過期回調函數(shù)
             // 同key重復調用，會產生多個延時任務，就是多次調用清理函數(shù)，但是不會產生多次回調，因為回調取決于過期時間和回調函數(shù)）
             scheduledExecutorService.schedule(this::clearExpireData, ms, TimeUnit.MILLISECONDS);
 ?
             //假定系統(tǒng)時間不修改前提下的過期時間
             return System.currentTimeMillis() + ms;
         } finally {
             expireKeysWriteLock.unlock();
         }
     }
     /**
      * 清理過期的數(shù)據(jù)
      * 調用時機：設置了過期回調函數(shù)的key的延時任務調用
      */
     private void clearExpireData() {
         // 查找過期key
         Long curTimestamp = System.nanoTime() / ONE_MILLION;
         Map<Long, List<String>> expiredKeysMap = new LinkedHashMap<>();
         expireKeysReadLock.lock();
         try {
             // 過期時間在【從前至此刻】區(qū)間內的都為過期的key
             // headMap():獲取從頭到 curTimestamp 元素的集合：不包含 curTimestamp
             SortedMap<Long, List<String>> sortedMap = this.expireKeysMap.headMap(curTimestamp, true);
             expiredKeysMap.putAll(sortedMap);
         } finally {
             expireKeysReadLock.unlock();
         }
 ?
         for (Map.Entry<Long, List<String>> entry : expiredKeysMap.entrySet()) {
             for (String key : entry.getValue()) {
                 // 刪除數(shù)據(jù)
                 Long val = this.remove(key);
                 // 首次調用刪除（val!=null，前提：val存儲值都不為null）
                 if (val != null) {
                     // 如果存在過期回調函數(shù)，則執(zhí)行回調
                     ExpireCallback<String, Long> callback;
                     expireKeysReadLock.lock();
                     try {
                         callback = this.keyExpireCallbackMap.get(key);
                     } finally {
                         expireKeysReadLock.unlock();
                     }
                     if (callback != null) {
                         // 回調函數(shù)創(chuàng)建新線程調用，防止因為耗時太久影響線程池的清理工作
                         // 這里為什么不用線程池調用，因為ScheduledThreadPoolExecutor線程池僅支持核心線程數(shù)設置，不支持非核心線程的添加
                         // 核心線程數(shù)用一個就可以完成清理工作，添加額外的核心線程數(shù)浪費了
                         new Thread(() -> callback.onExpire(key, val), "callback-thread-" + UUID.randomUUID()).start();
                     }
                 }
                 this.keyExpireCallbackMap.remove(key);
             }
             this.expireKeysMap.remove(entry.getKey());
         }
     }
 }