缓存是万恶之源

public class LookasideCache {
    private CacheCluster cacheCluster;
    private LeaseUtils leaseUtils;
    /**
     * 使用 lookaside 缓存读取某个值
     *
     * @param key 要返回谁的值
     * @param sourceOfTruthComputation 如果有必要的话，
     *                                 用于从真实源中获取值的函数。
     *                                 计算被认为是昂贵的
     *                                 并且会加大真实数据存储源的负载。
     *                                
     * @return a byte[] 表示与查找 key 相关联的值。
     */
    public byte[] read(byte[] key, Function<byte[], byte[]> sourceOfTruthComputation) {
        return read(key, sourceOfTruthComputation, Collections.EMPTY_SET);
    }
    /**
     * 用于上述 read 方法的私用辅助方法，允许我们在堆栈上携带之前看到的租约集
     * 
     */
    private byte[] read(
        byte[] key,
        Function<byte[], byte[]> sourceOfTruthComputation,
        Set<Lease> previouslySeenLeases
    ) {
        // 首先查找所提供的 key 以及以前看到的所有租约。
        List<byte[]> cacheKeysToLookUp = new ArrayList<>();
        cacheKeysToLookUp.add(key);
        for (Lease previouslySeenLease : previouslySeenLeases) {
            cacheKeysToLookUp.add(previouslySeenLease.getNonce());
        }
        List<byte[]> valuesFromCacheServer = cacheCluster.get(cacheKeysToLookUp);
        byte[] valueForKey = valuesFromCacheServer.remove(0);
        // 检查该值是否隐藏在我们前面看到的某个租约的后面。
        for (byte[] valueForPreviouslySeenLease : valuesFromCacheServer) {
            if (valueForPreviouslySeenLease != null) {
                return valueForPreviouslySeenLease;
            }
        }
        if (valueForKey == null) {
            // 我们试着获取该 key 的租约。
            Lease newLease = leaseUtils.createNew();
            boolean leaseAddSucceeded = cacheCluster.atomicAdd(key, newLease.getNonce());
            if (leaseAddSucceeded) {
                // 我们设法获取该 key 的租约，这意味着需要我们去寻找真实源，
                // 然后用真实源里的值填充缓存。
                byte[] valueFromSourceOfTruth = sourceOfTruthComputation.apply(key);
                boolean checkAndSetSuccceeded = cacheCluster.atomicCheckAndSet(
                    key,
                    newLease.getNonce(),
                    valueFromSourceOfTruth
                );
                // 让我们使用租约的 nonce 作为 key， 并将我们计算的值与之关联。
                cacheCluster.set(newLease.getNonce(), valueFromSourceOfTruth);
                return valueFromSourceOfTruth;
            } else {
                // 另一个请求比我们先获得了租约。让我们重试。
                return read(key, sourceOfTruthComputation, previouslySeenLeases);
            }
        } else if (leaseUtils.isCacheValueLease(valueForKey)) {
            // 另一个缓存请求持有该 key 的租约，
            // 让我们给它一些时间来填满混存，然后再重试。
            sleep(100);
            previouslySeenLeases.add(leaseUtils.fromCacheValue(valueForKey));
            return read(key, sourceOfTruthComputation, previouslySeenLeases);
        } else {
            // 从缓存服务中获取值，然后返回。
            return valueForKey;
        }
    }
    private void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            System.err.println("Sleep interrupted.");
            e.printStackTrace();
        }
    }
}
interface CacheCluster {
    /**
     * 从缓存集群获取键的列表。
     * @param keys 要从缓存集群中获取键
     * @return byte[] 列表表示与提供的键相关联的值
     *  返回的列表将与提供的键列表并行，
     * 换句话说，与某个键关联的值在返回列表中的位置与键在键列表中的位置相同。
     * 返回列表中的空值表示缓存未命中。
     * 虽然这不是一个好的设计 API 的方法
     * 但对于这个算法的高层演示，它能很好的运行。
     */
    List<byte[]> get(List<byte[]> keys);
    /**
     * 设置值与缓存集群中所提供的键的关联关系
     */
    void set(byte[] key, byte[] value);
    /**
     * 当且仅当键尚未被设置时，为该键设置所提供的值。
     * 否则，操作失败。
     * @return 如果操作成功且设置了值，则返回 true，否则返回 false。
     */
    boolean atomicAdd(byte[] key, byte[] value);
    /**
     * 当且仅当键刚好与 expectedValue 相关关联时，为所提供的键设置 valueToSet。
     * @return 如果操作成功且设置了值，则返回 true，否则返回 false。
     */
    boolean atomicCheckAndSet(byte[] key, byte[] expectedValue, byte[] valueToSet);
}
interface Lease {
    byte[] getNonce();
}
interface LeaseUtils {
    Lease createNew();
    Lease fromCacheValue(byte[] nonce);
    boolean isCacheValueLease(byte[] value);
}