基于线程安全的缓存工具类 CacheUtil

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.*;

/**
 * @author 
 * @date 2019/12/13
 * @desc 基于线程安全的缓存工具类
 */
public class CacheUtil {

    private static Logger LOGGER = LoggerFactory.getLogger(CacheUtil.class);

    private static final ConcurrentMap<String, Future<String>> cache = new ConcurrentHashMap<>();

    public static String getByKey(String key) {
        Future<String> future = cache.get(key);
        if (future == null) {
            return null;
        }
        try {
            return future.get();
        } catch (Exception e) {
            LOGGER.error("get wk_id from cache error:{}", e);
        }
        return null;
    }

    /**
     * 存入缓存
     *
     * @param key
     * @param val
     * @return
     */
    public static String putIntoCache(String key, String val) {
        Future<String> future = cache.get(key);
        if (future == null) {
            Callable<String> callable = new Callable<String>() {
                @Override
                public String call() throws Exception {
                    return new String(val);
                }
            };
            FutureTask<String> task = new FutureTask<>(callable);
            future = cache.putIfAbsent(key, task);
            if (future == null) {
                future = task;
                task.run();
            }
        }
        try {
            return future.get();
        } catch (Exception e) {
            cache.remove(key);
            LOGGER.error("put wk_id into cache error:{}", e);
        }
        return null;
    }

    /**
     * 更新缓存中相应的值
     *
     * @param key
     * @param val
     * @return
     */
    public static String updateCache(String key, String val) {
        Future<String> future = cache.get(key);
        if (future == null) {
            return null;
        }

        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                return new String(val);
            }
        };
        FutureTask<String> task = new FutureTask<>(callable);
        Future<String> replace = cache.replace(key, task);
        if (replace != null) {
            future = task;
            task.run();
        }
        try {
            return task.get();
        } catch (Exception e) {
            cache.remove(key);
            LOGGER.error("update cache error:{}", e);
        }
        return null;
    }
}