用ConcurrentHashMap 实现JVM缓存

为什么用缓存

• 提升应用程序性能
• 降低数据库成本
• 减少后端负载
• 可预测的性能
• 消除数据库热点
• 提高读取吞吐量（IOPS）

读多写少用缓存

常用的分布式缓存有Redis、Memcached等。
但是在单机的情况下，咱们完全可以使用内部缓存达到更好的效果。当需要扩展为分布式集群环境时，更改实现类就可以了。

JSR107规范

http://jcp.org/en/jsr/detail?id=107

1. 目标
   为应用程序提供缓存Java对象的功能。
   定义了一套通用的缓存概念和工具。
   最小化开发人员使用缓存的学习成本。
   最大化应用程序在使用不同缓存实现之间的可移植性。
   支持进程内和分布式的缓存实现。

2. 核心概念
   Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。
   CachingProvider定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider。
   CacheManager定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有。
   Cache是一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个CacheManager所拥有。
   Entry是一个存储在Cache中的key-value对。
   每一个存储在Cache中的条目有一个定义的有效期，即Expiry Duration。
   一旦超过这个时间，条目为过期的状态。一旦过期，条目将不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置。

// 用map实现一个简单的缓存功能
public class MapCacheDemo {

    // 我使用了  ConcurrentHashMap，线程安全的要求。
    //我使用SoftReference <Object>  作为映射值，因为软引用可以保证在抛出OutOfMemory之前，如果缺少内存，将删除引用的对象。
    //在构造函数中，我创建了一个守护程序线程，每5秒扫描一次并清理过期的对象。
    private static final int CLEAN_UP_PERIOD_IN_SEC = 5;

  private static ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
  private final ConcurrentHashMap<String, SoftReference<CacheObject>> cache = new ConcurrentHashMap<>();

    public MapCacheDemo() {
        scheduledThreadPoolExecutor.setThreadFactory(new ThreadFactoryBuilder()
                .setNameFormat("demo-pool-%d").build());
        scheduledThreadPoolExecutor.scheduleAtFixedRate(()->cache.entrySet().removeIf(entry -> Optional.ofNullable(entry.getValue()).map(SoftReference::get).map(CacheObject::isExpired).orElse(false)),
                5,5,TimeUnit.SECONDS);
    }

    public void add(String key, Object value, long periodInMillis) {
        if (key == null) {
            return;
        }
        if (value == null) {
            cache.remove(key);
        } else {
            long expiryTime = System.currentTimeMillis() + periodInMillis;
            cache.put(key, new SoftReference<>(new CacheObject(value, expiryTime)));
        }
    }

    public void remove(String key) {
        cache.remove(key);
    }

    public Object get(String key) {
        return Optional.ofNullable(cache.get(key)).map(SoftReference::get).filter(cacheObject -> !cacheObject.isExpired()).map(CacheObject::getValue).orElse(null);
    }

    public void clear() {
        cache.clear();
    }

    public long size() {
        return cache.entrySet().stream().filter(entry -> Optional.ofNullable(entry.getValue()).map(SoftReference::get).map(cacheObject -> !cacheObject.isExpired()).orElse(false)).count();
    }

    // 缓存对象value
    private static class CacheObject {
        private Object value;
        private long expiryTime;

        private CacheObject(Object value, long expiryTime) {
            this.value = value;
            this.expiryTime = expiryTime;
        }

        boolean isExpired() {
            return System.currentTimeMillis() > expiryTime;
        }

        public Object getValue() {
            return value;
        }

        public void setValue(Object value) {
            this.value = value;
        }
    }
}