Java TimedCache 带时间缓存工具类详解使用

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.4.6</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>30.1.1-jre</version>
        </dependency>

import cn.hutool.cache.CacheUtil;
import cn.hutool.cache.impl.TimedCache;
import cn.hutool.core.thread.ThreadUtil;
 
/** @Author huyi @Date 2021/10/12 17:00 @Description: */
public class TimedCacheUtils {
  private static final TimedCache<String, String> TIMED_CACHE = CacheUtil.newTimedCache(5000);
 
  static {
    /** 每5ms检查一次过期 */
    TIMED_CACHE.schedulePrune(5);
  }
 
  /**
   * 存入键值对，提供消逝时间
   *
   * @param key
   * @param value
   * @param timeout
   */
  public static void put(String key, String value, Long timeout) {
    /** 设置消逝时间 */
    TIMED_CACHE.put(key, value, timeout);
  }
 
  /**
   * 每次重新get一次缓存，均会重新刷新消逝时间
   * @param key
   * @return
   */
  public static String get(String key) {
    return TIMED_CACHE.get(key);
  }
 
  public static void main(String[] args) {
    put("haha", "1", 3000L);
    ThreadUtil.sleep(2000);
    //    if (TIMED_CACHE.containsKey("haha")) {
    //      System.out.println("aa");
    //    }
    System.out.println("第1次结果:" + get("haha"));
    ThreadUtil.sleep(2000);
    System.out.println("第2次结果:" + get("haha"));
    ThreadUtil.sleep(5000);
    System.out.println("第3次结果:" + get("haha"));
    // 取消定时清理
    TIMED_CACHE.cancelPruneSchedule();
  }
}

    put("haha", "1", 3000L);
    ThreadUtil.sleep(2000);
    if (TIMED_CACHE.containsKey("haha")) {
      System.out.println("第1次结果:缓存存在");
    }
//    System.out.println("第1次结果:" + get("haha"));
    ThreadUtil.sleep(2000);
    System.out.println("第2次结果:" + get("haha"));
    ThreadUtil.sleep(5000);
    System.out.println("第3次结果:" + get("haha"));
    // 取消定时清理
    TIMED_CACHE.cancelPruneSchedule();

import cn.hutool.cache.CacheUtil;
import cn.hutool.cache.impl.TimedCache;
import cn.hutool.core.thread.ThreadUtil;
import com.google.common.util.concurrent.*;
import org.checkerframework.checker.nullness.qual.Nullable;
 
import java.text.MessageFormat;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.function.Consumer;
 
/** @Author huyi @Date 2021/10/12 10:57 @Description: 时间缓存工具 */
public class TimedCacheUtils {
  private static final TimedCache<String, String> TIMED_CACHE = CacheUtil.newTimedCache(5000);
  /** 线程池 */
  private static final ExecutorService executorService = Executors.newCachedThreadPool();
 
  private static final ListeningExecutorService listeningExecutorService =
      MoreExecutors.listeningDecorator(executorService);
  /** 回调方法映射 */
  private static ConcurrentHashMap<String, Consumer<String>> callbackMap;
 
  /**
   * 存入键值对，添加过期时间，和消费回调
   *
   * @param key
   * @param timeout
   * @param consumer
   */
  public static void put(String key, String value, Long timeout, Consumer<String> consumer) {
    TIMED_CACHE.put(key, value, timeout);
    addListen(key, consumer);
  }
 
  /**
   * 获取缓存值
   *
   * @param key
   * @return
   */
  public static String get(String key) {
    return TIMED_CACHE.get(key);
  }
 
  /**
   * 删除缓存和回调映射
   *
   * @param key
   */
  public static void remove(String key) {
    callbackMap.remove(key);
    TIMED_CACHE.remove(key);
  }
 
  /**
   * 添加监听器
   *
   * @param key
   * @param consumer
   */
  public static void addListen(String key, Consumer<String> consumer) {
    ListenableFuture<String> listenableFuture =
        listeningExecutorService.submit(
            () -> {
              while (TIMED_CACHE.containsKey(key)) {
                ThreadUtil.sleep(500);
              }
              return key;
            });
    Futures.addCallback(
        listenableFuture,
        new FutureCallback<String>() {
          @Override
          public void onSuccess(@Nullable String s) {
            consumer.accept(s);
          }
 
          @Override
          public void onFailure(Throwable throwable) {
            throwable.printStackTrace();
          }
        },
        listeningExecutorService);
  }
 
  public static void main(String[] args) {
    put("haha", "1", 3000L, x -> System.out.println(MessageFormat.format("[{0}] - 缓存消逝", x)));
    ThreadUtil.sleep(2000);
    System.out.println(get("haha"));
    ThreadUtil.sleep(2000);
    System.out.println(get("haha"));
    ThreadUtil.sleep(5000);
    System.out.println(get("haha"));
    // 关闭监听线程池
    listeningExecutorService.shutdown();
  }
}