zoukankan      html  css  js  c++  java

  • Guava---缓存之LRU算法

    GuavaCache学习笔记一：自定义LRU算法的缓存实现

     

    前言

    今天在看GuavaCache缓存相关的源码，这里想到先自己手动实现一个LRU算法。于是乎便想到LinkedHashMap和LinkedList+HashMap, 这里仅仅是作为简单的复习一下。

    LRU

    LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。

    代码实现原理

    LinkedList + HashMap： LinkedList其实是一个双向链表，我们可以通过get和put来设置最近请求key的位置，然后hashMap去存储数据
    LinkedHashMap：LinkedHashMap是继承自HashMap，只不过Map中的Node节点改为了双向节点，双向节点可以维护添加的顺序，在LinkedHashMap的构造函数中有一个accessOrder， 当设置为true后，put和get会自动维护最近请求的位置到last。

    LinkedList+HashMap代码实现

    LRUCache接口：

    /**
 * @Description:
 * @Author: wangmeng
 * @Date: 2018/12/8-10:49
 */
public class LinkedListLRUTest {
    public static void main(String[] args) {
        LRUCache<String, String> cache = new LinkedListLRUCache<>(3);
        cache.put("1", "1");
        cache.put("2", "2");
        cache.put("3", "3");
        System.out.println(cache);

        cache.put("4", "4");
        System.out.println(cache);

        System.out.println(cache.get("2"));
        System.out.println(cache);
    }
}

    LinkedList实现：

    /**
 * @Description:使用LinkedList+HashMap来实现LRU算法
 * @Author: wangmeng
 * @Date: 2018/12/8-10:41
 */
public class LinkedListLRUCache<K, V> implements LRUCache<K, V> {

    private final int limit;
    private final LinkedList<K> keys = new LinkedList<>();
    private final Map<K, V> cache = Maps.newHashMap();

    public LinkedListLRUCache(int limit) {
        this.limit = limit;
    }

    @Override
    public void put(K key, V value) {
        Preconditions.checkNotNull(key);
        Preconditions.checkNotNull(value);
        if (keys.size() >= limit) {
            K oldesKey = keys.removeFirst();
            cache.remove(oldesKey);
        }

        keys.addLast(key);
        cache.put(key, value);
    }

    @Override
    public V get(K key) {
        boolean exist = keys.remove(key);
        if (!exist) {
            return null;
        }

        keys.addLast(key);
        return cache.get(key);
    }

    @Override
    public void remove(K key) {

        boolean exist = keys.remove(key);
        if (exist) {
            keys.remove(key);
            cache.remove(key);
        }
    }

    @Override
    public int size() {
        return keys.size();
    }

    @Override
    public void clear() {
        keys.clear();
        cache.clear();
    }

    @Override
    public int limit() {
        return this.limit;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        for (K key : keys) {
            builder.append(key).append("=").append(cache.get(key)).append(";");
        }
        return builder.toString();
    }
}

    LinkedList测试类：

    /**
 * @Description:
 * @Author: wangmeng
 * @Date: 2018/12/8-10:49
 */
public class LinkedListLRUTest {
    public static void main(String[] args) {
        LRUCache<String, String> cache = new LinkedListLRUCache<>(3);
        cache.put("1", "1");
        cache.put("2", "2");
        cache.put("3", "3");
        System.out.println(cache);

        cache.put("4", "4");
        System.out.println(cache);

        System.out.println(cache.get("2"));
        System.out.println(cache);
    }
}

    LinkedList测试类返回值：

    1=1;2=2;3=3;
2=2;3=3;4=4;
2
3=3;4=4;2=2;

    LinkedHashMap实现

    /**
 * @Description: 不是一个线程安全的类，这里是使用LinkedHashMap来做LRU算法
 * @Author: wangmeng
 * @Date: 2018/12/8-10:14
 */
public class LinkedHashLRUCache<K, V> implements LRUCache<K, V> {

    private static class InternalLRUCache<K, V> extends LinkedHashMap<K, V> {

        final private int limit;
        private InternalLRUCache(int limit) {
            super(16, 0.75f, true);
            this.limit = limit ;
        }

        //实现remove元素的方法，这个是重写了LinkedHashMap中的方法。因为在HashMap的putVal会调用afterNodeInsertion(), 而这个方法会判断removeEldestEntry方法。
        @Override
        protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
            return size() > limit;
        }
    }


    private final int limit;
    //使用组合关系优于继承，这里只对外暴漏LRUCache中的方法
    private final InternalLRUCache<K, V> internalLRUCache;
    public LinkedHashLRUCache(int limit) {
        Preconditions.checkArgument(limit > 0, "The limit big than zero.");
        this.limit = limit;
        this.internalLRUCache = new InternalLRUCache(limit);

    }

    @Override
    public void put(K key, V value) {
        this.internalLRUCache.put(key, value);
    }

    @Override
    public V get(K key) {
        return this.internalLRUCache.get(key);
    }

    @Override
    public void remove(K key) {
        this.internalLRUCache.remove(key);
    }

    @Override
    public int size() {
        return this.internalLRUCache.size();
    }

    @Override
    public void clear() {
        this.internalLRUCache.clear();
    }

    @Override
    public int limit() {
        return this.limit;
    }

    @Override
    public String toString() {
        return internalLRUCache.toString();
    }
}

    LinkedHashMap测试类：

    /**
 * @Description:
 * @Author: wangmeng
 * @Date: 2018/12/8-10:30
 */
public class LinkedHashLRUTest {
    public static void main(String[] args) {
        LRUCache<String, String> cache = new LinkedHashLRUCache<>(3);
        cache.put("1", "1");
        cache.put("2", "2");
        cache.put("3", "3");
        System.out.println(cache);

        cache.put("4", "4");
        System.out.println(cache);

        System.out.println(cache.get("2"));
        System.out.println(cache);
    }
}

    LinkedHashMap测试结果：

    {1=1, 2=2, 3=3}
{2=2, 3=3, 4=4}
2
{3=3, 4=4, 2=2}

    文章目录
    简介
    实现LRU
    LinkedHashMap中LRU算法实现
    简介
    LRU全称是Least Recently Used，即最近最久未使用的意思。

    LRU算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。

    实现LRU
    1.用一个数组来存储数据，给每一个数据项标记一个访问时间戳，每次插入新数据项的时候，先把数组中存在的数据项的时间戳自增，并将新数据项的时间戳置为0并插入到数组中。每次访问数组中的数据项的时候，将被访问的数据项的时间戳置为0。当数组空间已满时，将时间戳最大的数据项淘汰。

    2.利用一个链表来实现，每次新插入数据的时候将新数据插到链表的头部；每次缓存命中（即数据被访问），则将数据移到链表头部；那么当链表满的时候，就将链表尾部的数据丢弃。

    3.利用链表和hashmap。当需要插入新的数据项的时候，如果新数据项在链表中存在（一般称为命中），则把该节点移到链表头部，如果不存在，则新建一个节点，放到链表头部，若缓存满了，则把链表最后一个节点删除即可。在访问数据的时候，如果数据项在链表中存在，则把该节点移到链表头部，否则返回-1。这样一来在链表尾部的节点就是最近最久未访问的数据项。

    对于第一种方法，需要不停地维护数据项的访问时间戳，另外，在插入数据、删除数据以及访问数据时，时间复杂度都是O(n)。对于第二种方法，链表在定位数据的时候时间复杂度为O(n)。所以在一般使用第三种方式来是实现LRU算法。

    LinkedHashMap中LRU算法实现
    /**
    * @Author: Kingcym
    * @Description: 非线程安全
    * @Date: 2018/11/11 19:09
    */
    public class LinkedHashLRUcache<k, v> {
    /**
    * LinkedHashMap（自身实现了ＬＲＵ算法）
    * 1.有序
    * 2.每次访问一个元素，都会提到最后面去
    */
    private static class InternalLRUcache<k, v> extends LinkedHashMap<k, v> {
    private final int limit;

    private InternalLRUcache(int limit) {
    super(16, 0.75f, true);
    this.limit = limit;
    }

    //是否删除最老的数据
    @Override
    protected boolean removeEldestEntry(Map.Entry<k, v> eldest) {
    return size() > limit;
    }
    }

    private final int limit;
    private final InternalLRUcache<k, v> internalLRUcache;


    public LinkedHashLRUcache(int limit) {
    Assert.state(limit > 0, "limit必须大于0");
    this.limit = limit;
    this.internalLRUcache = new InternalLRUcache(limit);
    }



    public void put(k key, v value) {
    this.internalLRUcache.put(key, value);
    }

    public v get(k key) {
    return this.internalLRUcache.get(key);
    }

    public void remove(k key) {
    this.internalLRUcache.remove(key);
    }

    public int size() {
    return this.internalLRUcache.size();
    }

    public void clear() {
    this.internalLRUcache.clear();
    }

    public String toString() {
    return internalLRUcache.toString();
    }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    当存在热点数据时，LRU的效率很好，但偶发性的、周期性的批量操作会导致LRU命中率急剧下降，缓存污染情况比较严重。
     


    参考：GuavaCache学习笔记一：自定义LRU算法的缓存实现
    参考：Guava---缓存之LRU算法
  • 相关阅读:
    多态
    接口和抽象类
    反射
    C++ 模板和 C# 泛型的区别
    基础类库中的泛型
    运行时中的泛型
    泛型代码中的 default 关键字
    泛型委托
    泛型方法
    泛型接口
  • 原文地址：https://www.cnblogs.com/aspirant/p/11734765.html
Copyright © 2011-2022 走看看