缓存是万恶之源

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);}