制作Java完整的未来缓存原子能

Question

我一直在尝试设置一个简单的原子能完整的未来缓存，该缓存将String键和callable类 并缓存执行和结果。我知道我可以使用咖啡因，但仍然想了解如何在没有种族条件的情况下完成此操作。插入和清理。

在这个简单的类中，我有两个简化的缓存：executions缓存，可以使尚未完成运行的可可的跟踪以及结果缓存，以跟踪结果（最终，这将是溢出磁盘的ehcache）

public class AsyncCache {

    ExecutorService executor = Executors.newFixedThreadPool(10);
    ConcurrentHashMap<String, CompletableFuture<Object>> executions = new ConcurrentHashMap<>();
    ConcurrentHashMap<String, Object> results = new ConcurrentHashMap<>();

    public CompletableFuture<Object> get(String key, Callable<Object> callable) {

        Object result = results.get(key);
        if (result != null) {
            return CompletableFuture.completedFuture(result);
        }

        return executions.computeIfAbsent(key, k -> {

            CompletableFuture<Object> future = CompletableFuture.supplyAsync(() -> {
                try {
                    return callable.call();
                } catch (Exception e) {
                    throw new CompletionException(e);
                }
            }, executor);

            return future.whenComplete((Object r, Throwable t) -> {
                if (executions.remove(k) != null) {
                    results.put(k, result);
                }
            });

        });

    }

    public void clear() {
        results.clear();
        executions.clear();
    }

}

我相信该代码有两个问题。首先，行中存在一个同步问题：

if (executions.remove(k) != null) {
    results.put(k, result);
}

在之间删除（k） and results.put（k，result）可以有一个新的get < /code>调用Resulte中尚未在executions中删除的相同密钥在结果缓存中。

其次，行中还有另一个同步问题：

results.clear();
executions.clear();

在两个clear（）之间，可以有一个新的get调用，无法从结果< /code>映射，但会从executions地图中获得停滞的响应。

关于如何解决此问题的任何想法，而无需天真地同步所有内容。

---

编辑。

如果我引入每钥匙锁定以防止阅读和写作，该怎么办？这样的事情：

    ConcurrentMap<String, ReadWriteLock> locks = new ConcurrentHashMap<String, ReadWriteLock>();

    public CompletableFuture<Object> get1(String key, Callable<Object> callable) {

        ReadWriteLock reading = locks.computeIfAbsent(key, r -> new ReentrantReadWriteLock());
        reading.readLock().lock();
        try {

            Object result = results.get(key);
            if (result != null) {
                return CompletableFuture.completedFuture(result);
            }

            return executions.computeIfAbsent(key, k -> {

                CompletableFuture<Object> future = CompletableFuture.supplyAsync(() -> {
                    try {
                        return callable.call();
                    } catch (Exception e) {
                        throw new CompletionException(e);
                    }
                }, executor);

                return future.whenComplete((Object r, Throwable t) -> {

                    ReadWriteLock writing = locks.computeIfAbsent(k, w -> new ReentrantReadWriteLock());
                    writing.writeLock().lock();
                    try {
                        if (executions.remove(k) != null) {
                            results.put(k, r);
                        }
                    } finally {
                        writing.writeLock().unlock();
                        locks.remove(k);
                    }

                });

            });

        } finally {
            reading.readLock().unlock();
            locks.remove(key);
        }

    }

这仍然会留下有关如何编写clear（）方法的问题。

Answer 1

这是我最终使用的代码。我经历了许多修订，但找不到任何明显的僵局或比赛条件。我要把它留在这里，以防万一对别人有用。

public class AsyncCache {

    ExecutorService executor = Executors.newFixedThreadPool(10);
    ConcurrentHashMap<String, CompletableFuture<Object>> executions = new ConcurrentHashMap<>();

    ReentrantReadWriteLock guard = new ReentrantReadWriteLock();
    MutableConfiguration<String, Object> configuration = new MutableConfiguration<>();
    Cache<String, Object> results = Caching.getCachingProvider().getCacheManager().createCache("results", configuration);

    public CompletableFuture<Object> get(String key, Callable<Object> callable) {

        guard.readLock().lock();
        try {

            // Attempt to get from the cache first. Only pay attention to
            // the cache eviction policies.

            Object result = results.get(key);
            if (result != null) {
                return CompletableFuture.completedFuture(result);
            }

            // Attempt to get from the current executions second. Make sure
            // that the cache and executions is guarded by a read write lock.

            return executions.computeIfAbsent(key, k -> {

                CompletableFuture<Object> future = CompletableFuture.supplyAsync(() -> {
                    try {
                        return callable.call();
                    } catch (Exception e) {
                        throw new CompletionException(e);
                    }
                }, executor);

                return future.whenComplete((Object r, Throwable t) -> {

                    guard.writeLock().lock();
                    try {
                        if (executions.remove(k) != null) {
                            if (r != null) {
                                results.put(k, r);
                            }
                        }
                    } finally {
                        guard.writeLock().unlock();
                    }

                });

            });

        } finally {
            guard.readLock().unlock();
        }

    }

    public void clear() {

        // Guard the cache and executions with a write lock.

        guard.writeLock().lock();
        try {
            executions.clear();
            results.clear();
        } finally {
            guard.writeLock().unlock();
        }

    }

}

我仍然不确定如何检查这是否过于限制（锁定超出所需的锁定）。对于我的用例，可可的山货量可能需要100到3000毫秒，并且可以每15分钟左右调用清晰的方法。

也许我什至不需要executions是concurrenthashmap，因为读取和写入受到保护。