Question

在给定的示例中，我有一个内部类，它定义了一个想象的CacheLoaderWriter类内部的读取ExampleCache，它将抽象缓存操作，以便第三方认为他们访问数据结构（键值对）。我的问题涉及loadAll方法。

如果写loadAll并行写入EhCache，是否会有记录突变或不稳定的风险？是否构建了EhCache来处理用户定义的并发？

    class ExampleCacheLoader implements CacheLoaderWriter<String, ArrayList> {


            private HashMap<String, ArrayList> map;

            public CacheLoader() {
                map = new HashMap<>();
            }

            @Override
            public ArrayList<String> load(String s) throws Exception {

                Map.Entry<String, ArrayList<String>> personEntry = getPersonAliases(s);
                if(!map.containsKey(personEntry.getKey())){
                    map.put(personEntry.getKey(), personEntry.getValue());
                }
                return map.get(personEntry.getKey());
            }

            @Override
            public Map<String, ArrayList> loadAll(
                    Iterable<? extends String> keys) throws Exception {
                Map<String, ArrayList> localTempMap = new HashMap<>();
                Stream keyStream =  StreamSupport.stream(entries.spliterator(), true);
                keyStream.forEach(key -> {
                    localTempMap.putIfAbsent(
                            getterExample(key).getKey(),
                            getterExample(key).getValue());
                });

                map.putAll(localTempMap);
                return localTempMap;
            }
            .

            .

            .

Answer 1

Ehcache是一个专为并发访问而设计的库，因此以最佳方式处理多线程，并发突变和相关问题。

现在您对CacheLoaderWriter的理解似乎有问题。您不应该从CacheLoaderWriter访问缓存，而是在需要时缓存将访问CacheLoaderWriter，这是load*方法在请求映射但未在缓存。

但是，您的CacheLoaderWriter实现必须线程安全，因为Ehcache将同时使用它。同样在您提议的实现中，您将在CacheLoaderWriter内部维护状态，这与Cache将执行的操作是多余的...如果我正确理解您要实现的目标。

并行写Ehcache会有危险吗？

1 个答案: