单线程缓存

单线程缓存器

用户本地单线程缓存，可以防止重复查询数据。注意：由于缓存了，所以中间不能进行更新和删除，主要用于防止多次查询相同的数据。

源码：

package io.gitee.chearnee.fw.common.utils.cache;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;
import java.util.stream.IntStream;

/**
 * 线程缓存器，只缓存当前线程的数据
 */
public class ThreadLocalCacheUtil implements AutoCloseable {
    private final ThreadLocal<Map<?, ?>> resultCache = new ThreadLocal<>();


    public static ThreadLocalCacheUtil getInstance() {
        return new ThreadLocalCacheUtil();
    }


    /**
     * 线程缓存，值可以存入null，来作为缓存
     *
     * @param key
     * @param supplier
     * @param <K>
     * @param <V>
     * @return
     */
    @SuppressWarnings("unchecked")
    public <K, V> V get(K key, Supplier<V> supplier) {
        Map<K, V> functionResultMap = (Map<K, V>) resultCache.get();
        if (functionResultMap == null) {
            Map<K, V> reusltMap = new HashMap<>();
            V v = supplier.get();
            reusltMap.put(key, v);
            resultCache.set(reusltMap);
            return v;
        }
        if (functionResultMap.containsKey(key)) {
            return functionResultMap.get(key);
        }
        V v = supplier.get();
        functionResultMap.put(key, v);
        return v;
    }

    public void removeResultCache() {
        resultCache.remove();
    }

    @Override
    public void close() {
        removeResultCache();
    }
}

食用方式：

    public static void main(String[] args) {
        try (ThreadLocalCacheUtil instance = ThreadLocalCacheUtil.getInstance()) {
            IntStream.range(0, 10)
                    .forEach(e -> {
                        String s = instance.get("666", () -> {
                            System.out.println("我只获取一次");
                            //....
                            // 要缓存的值xxx
                            return "缓存了";
                        });
                        System.out.println(s);
                    });

        }
    }

例子：一个线程中只执行了一次相同的key只执行了一次方法