1

介绍

我使用ArrayDeque以下 Generics解决方案实现了一个带有 LRU 策略的简单缓存：

public class Cache<T> extends ArrayDeque<T> implements Serializable {
    private static final long serialVersionUID = 1L;
    private int MAX_SIZE;

    public Cache(int maxSize) {
        MAX_SIZE = maxSize;
    }

    public void store(T e) {
        if (super.size() >= MAX_SIZE) {                 
            this.pollLast();
        }
        this.addFirst(e);       
    }

    public T fetch(T e) {
        Iterator<T> it = this.iterator();
        while (it.hasNext()) {
            T current = it.next();
            if (current.equals(e)) {
                this.remove(current);
                this.addFirst(current);
                return current;
            }
        }
        return null;
    }

}

问题

当我实例化类并推送一个元素时，

Cache<CachedClass> cache = new Cache<CachedClass>(10);
cache.store(new CachedClass());

此时队列不包含任何内容。

为什么会这样？

观察

顺便说一句，CachedClass覆盖了方法.equals()。

测试

 public class CacheTest {

    @Test
    public void testStore() {
        Cache<Integer> cache = new Cache<Integer>(3);

        cache.store(1);
        assertTrue(cache.contains(1));

        cache.store(2);
        cache.store(3);
        cache.store(4);

        assertEquals(cache.size(), 3);      
    }

    @Test
    public void testFetch() {
        Cache<Context> cache = new Cache<Context>(2);

        Context c1 = new Context(1);
        Context c2 = new Context(2);

        cache.store(c1);
        cache.store(c2);                

        assertEquals((Context) cache.peekFirst(), (new Context(2)));

        Context c = cache.fetch(c1);

        assertTrue(c == c1);        
        assertEquals(cache.size(), 2);
        assertEquals((Context) cache.peekFirst(), (new Context(1)));

    }

 }

编辑它成功通过了两个测试。

它通过了第一次测试。它失败AssertException了

assertTrue(cache.peekFirst() == 1);

第二次测试，

4

3 回答 3

1

LinkedHashMap 的 Javadoc 说

“这种地图非常适合构建 LRU 缓存。”

你真的需要一个很好的理由来忽略这一点。我的猜测是，puts 的实现和使用 Map 的 get 实现之间的性能将无法区分——但是，嘿，你为什么不运行自己的基准测试。

最后，您的实现（以及 LinkedHashMap 提供的实现）不是线程安全的。如果这对您来说是个问题，同步逻辑将增加性能开销。

于 2012-11-05T17:23:59.033 回答
0

我在主要方法中这样做：

    Cache<Integer> cache = new Cache<Integer>(10);
    cache.store(new Integer(0)); 
    System.out.println(cache.size()); // prints 1
    Integer foo = cache.fetch(new Integer(0));
    System.out.println(foo == null); // prints false

它打印 1，所以你的Cache. 工作正常。

为了获取您的CachedClassmuss override equals()。您的代码无需更改即可按预期完美运行。

于 2012-11-05T14:51:22.907 回答
0

我使用 LinkedHashMap 作为 LRU 缓存。

public static <K,V> Map<K,V> lruCache(final int maxSize) {
    return new LinkedHashMap<K,V>(maxSize*4/3, 0.75f, true) {
        @Override
        protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
            return size() > maxSize;
        }
    };
}

一个重要的区别是键与值相关联。如果您将缓存作为一组实现，您所能做的就是确认您已经拥有的对象是否在缓存中，恕我直言，这不是很有用。

测试

@Test
public void testStore() {
    Map<Integer, String> cache = lruCache(3);
    cache.put(1, "one");
    assertEquals("one", cache.get(1));

    cache.put(2, "two");
    cache.put(3, "three");
    cache.put(4, "four");

    assertEquals(cache.size(), 3);
    assertEquals(null, cache.get(1));
}

@Test
public void testFetch() {
    Map<Integer, String> cache = lruCache(3);

    cache.put(1, "one");
    cache.put(2, "two");

    assertEquals((Integer) 1, cache.keySet().iterator().next());

    String s = cache.get(1);

    assertEquals("one", s);
    assertEquals(cache.size(), 2);
    assertEquals((Integer) 2, cache.keySet().iterator().next());
}
于 2012-11-05T15:27:19.583 回答