实现一个线程安全并且带有失效时间的LRU缓存：

    1. /**
    2.  * @author KHighness
    3.  * @since 2021-08-15
    4.  */
    5. public class LRUCache<K, V> {
    7.     /**
    8.      * 最大容量
    9.      */
    10.     private final int maxCapacity;
    11.     /**
    12.      * 存储键值对
    13.      */
    14.     private ConcurrentHashMap<K, V> cache;
    15.     /**
    16.      * 存储有效键
    17.      */
    18.     private ConcurrentLinkedQueue<K> keys;
    19.     /**
    20.      * 读写锁
    21.      */
    22.     private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    23.     private Lock writeLock = readWriteLock.writeLock();
    24.     private Lock readLock = readWriteLock.readLock();
    26.     private ScheduledExecutorService scheduledExecutorService;
    28.     public LRUCache(int maxCapacity) {
    29.         if (maxCapacity < 0) {
    30.             throw new IllegalArgumentException("Illegal max capacity: " + maxCapacity);
    31.         }
    32.         this.maxCapacity = maxCapacity;
    33.         cache = new ConcurrentHashMap<>(maxCapacity);
    34.         keys = new ConcurrentLinkedQueue<>();
    35.         scheduledExecutorService = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors() + 1);
    36.     }
    38.     /**
    39.      * 放入缓存
    40.      *
    41.      * @param key          键
    42.      * @param value        值
    43.      * @param expireTime   过期时间
    44.      * @param unit         时间单位
    45.      * @return 如果缓存中已存在相同键，返回该键的值，否则返回插入的值
    46.      */
    47.     public V put(K key, V value, long expireTime, TimeUnit unit) {
    48.         if (expireTime < 0) {
    49.             throw new IllegalArgumentException("Illegal expire time: " + expireTime);
    50.         }
    51.         // 加写锁
    52.         writeLock.lock();
    53.         try {
    54.             V val = cache.get(key);
    55.             // key已经存在
    56.             if (val != null) {
    57.                 moveLast(key);
    58.                 cache.put(key, value);
    59.                 return val;
    60.             } else {
    61.                 // 缓存已满
    62.                 if (cache.size() == maxCapacity) {
    63.                     removeHead();
    64.                 }
    65.                 keys.add(key);
    66.                 cache.put(key, value);
    67.                 if (expireTime > 0) {
    68.                     removeAfterExpireTime(key, expireTime, unit);
    69.                 }
    70.                 return value;
    71.             }
    72.         } finally {
    73.             // 释放写锁
    74.             writeLock.unlock();
    75.         }
    76.     }
    78.     /**
    79.      * 获取键对应的值
    80.      *
    81.      * @param key 键
    82.      * @return 值
    83.      */
    84.     public V get(K key) {
    85.         // 加读锁
    86.         readLock.lock();
    87.         try {
    88.             V val = get(key);
    89.             if (val != null) {
    90.                 moveLast(key);
    91.                 return val;
    92.             }
    93.             return null;
    94.         } finally {
    95.             readLock.unlock();
    96.         }
    97.     }
    99.     /**
    100.      * 获取缓存中的键值对数量
    101.      *
    102.      * @return 键值对的数量
    103.      */
    104.     public int size() {
    105.         return cache.size();
    106.     }
    108.     /**
    109.      * 将key移动到队列尾部
    110.      */
    111.     private void moveLast(K key) {
    112.         keys.remove(key);
    113.         keys.add(key);
    114.     }
    116.     /**
    117.      * 移除队列头部key和缓存中的键值对
    118.      */
    119.     private void removeHead() {
    120.         K key = keys.poll();
    121.         if (key != null) {
    122.             cache.remove(key);
    123.         }
    124.     }
    126.     /**
    127.      * 清除过期key
    128.      */
    129.     private void removeAfterExpireTime(K key, long expireTime, TimeUnit unit) {
    130.         scheduledExecutorService.schedule(() -> {
    131.             cache.remove(key);
    132.             keys.remove(key);
    133.         }, expireTime, unit);
    134.     }
    135. }