寻找简单的 Java 内存缓存 [关闭]

Question

我正在寻找一个简单的 Java 内存缓存，它具有良好的并发性（因此 LinkedHashMap 还不够好），并且可以定期序列化到磁盘。

我需要但已证明很难找到的一个功能是一种“窥视”对象的方法。我的意思是从缓存中检索一个对象，而不会导致缓存保留该对象的时间比其他情况下更长。

更新：我没有提到的另一个要求是我需要能够就地修改缓存对象（它们包含浮点数组）。

任何人都可以提供任何建议吗？

Answer 1

这个怎么样：https://commons.apache.org/proper/commons-jcs/（更新到新地址，因为 JCS 现在在 Apache Commons 中）

Answer 2

Ehcache 是一个很好的解决方案，并且有一种方法可以窥视（getQuiet() 是方法），这样它就不会更新空闲时间戳。在内部，Ehcache 是用一组映射实现的，有点像 ConcurrentHashMap，因此它具有类似的并发优势。

Answer 3

试试Ehcache？它允许您插入自己的缓存到期算法，以便您可以控制您的窥视功能。

您可以序列化到磁盘、数据库、跨集群等...

Answer 4

如果您需要一些简单的东西，这是否符合要求？

Map<K, V> myCache = Collections.synchronizedMap(new WeakHashMap<K, V>());

它不会保存到磁盘，但你说你想要简单...

链接：

• Collections.synchronizedMap
• WeakHashMap

（正如 Adam 评论的那样，同步地图会影响性能。并不是说这个想法没有毛病，但作为一个快速而肮脏的解决方案就足够了。）

Answer 5

试试这个：

import java.util.*;

public class SimpleCacheManager {

    private static SimpleCacheManager instance;
    private static Object monitor = new Object();
    private Map<String, Object> cache = Collections.synchronizedMap(new HashMap<String, Object>());

    private SimpleCacheManager() {
    }

    public void put(String cacheKey, Object value) {
        cache.put(cacheKey, value);
    }

    public Object get(String cacheKey) {
        return cache.get(cacheKey);
    }

    public void clear(String cacheKey) {
        cache.put(cacheKey, null);
    }

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

    public static SimpleCacheManager getInstance() {
        if (instance == null) {
            synchronized (monitor) {
                if (instance == null) {
                    instance = new SimpleCacheManager();
                }
            }
        }
        return instance;
    }

}

Answer 6

自从最初提出这个问题以来，Google's Guava library 现在包含一个强大而灵活的缓存。我会推荐使用这个。

Answer 7

您可以轻松使用imcache。示例代码如下。

void example(){
    Cache<Integer,Integer> cache = CacheBuilder.heapCache().
    cacheLoader(new CacheLoader<Integer, Integer>() {
        public Integer load(Integer key) {
            return null;
        }
    }).capacity(10000).build(); 
}

Answer 8

内存中 Java 缓存的另一个选项是 cache2k。 内存性能优于 EHCache 和 google guava，见cache2k benchmarks page。

使用模式与其他缓存类似。这是一个例子：

Cache<String,String> cache = new Cache2kBuilder<String, String>() {}
  .expireAfterWrite(5, TimeUnit.MINUTES)    // expire/refresh after 5 minutes
  .resilienceDuration(30, TimeUnit.SECONDS) // cope with at most 30 seconds
                                          // outage before propagating 
                                          // exceptions
  .refreshAhead(true)                       // keep fresh when expiring
  .loader(new CacheLoader<String, String>() {
    @Override
    public String load(final String key) throws Exception {
      return ....;
    }
  })
  .build();
String val = cache.peek("something");
cache.put("something", "hello");
val = cache.get("something");

如果您有 google guava 作为依赖项，那么尝试 guava 缓存可能是一个不错的选择。

Answer 9

从jcabi-aspects 尝试@Cacheable。使用单个注释，您可以使整个方法结果可缓存在内存中：

public class Resource {
  @Cacheable(lifetime = 5, unit = TimeUnit.SECONDS)
  public String load(URL url) {
    return url.openConnection().getContent();
  }
}

另外，请阅读这篇文章：http://www.yegor256.com/2014/08/03/cacheable-java-annotation.html