`
pengzhaocheng16
  • 浏览: 180346 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

简单LRU算法实现缓存-update2

 
阅读更多
这次我们向大家介绍几种缓存中常见的算法,让各位对缓存算法有一个比较初步的了解。
贝莱蒂算法(Belady's Algorithm)
最有效率的缓存算法会丢掉未来最长时间内不使用的数据。这种理想情况被称作贝莱蒂最优算法或者千里眼算法。由于要预计数据要多久后才被使用基本上是不可能的,所以这种算法没有实际的可操作性。它的作用在于为不同的缓存算法订立一个优劣标准。
最近最少使用算法(LRU,Least Recently Used)
最近最少使用算法的思路是丢弃近段时间内最少被使用的数据。要实现这种算法需要跟踪数据何时被使用,用这种方法来筛选去近一段时间被最少使用次数的数据其代价往往是昂贵的。它的实现往往是通过在缓存数据上设立时间标志位,用以跟踪最近最少被使用的缓存数据。一个数据每被使用一次,其他数据的时间标志位数值就要增加。
最近最频繁使用算法(MRU,Most Recently Used)
最近最频繁使用算法和最近最少使用算法相反,它会首先丢弃最近最常使用的数据。有观点认为“当文件在顺序访问时,MRU算法是最佳选择”,抱有这样观点人也认为在反复进行大量数据的随机存储时,MRU因为倾向于保留旧的数据,随意比LRU算法有着更高的命中率。MRU算法经常用于旧的数据更常被用到的情况下。
伪LRU算法(PLRU,Pseudo-LRU)
因为缓存有着大量的关联性,LRU算法实现的代价往往比较昂贵。如果实际情况在丢弃任一个最近最少使用的数据就能满足,那么伪LRU算法就派上用场了,它为每一个缓存数据设立一个标志位就可以工作。
====================================
简单LRU算法实现缓存-update2
Posted on 2007-09-29 17:49 dennis 阅读(4845) 评论(5)  编辑  收藏 所属分类: java 、数据结构与算法 、my open-source 
update1:第二个实现,读操作不必要采用独占锁,缓存显然是读多于写,读的时候一开始用独占锁是考虑到要递增计数和更新时间戳要加锁,不过这两个变量都是采用原子变量,因此也不必采用独占锁,修改为读写锁。
update2:一个错误,老是写错关键字啊,LRUCache的maxCapacity应该声明为volatile,而不是transient。
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
   
   最简单的LRU算法实现,就是利用jdk的LinkedHashMap,覆写其中的removeEldestEntry(Map.Entry)方法即可,如下所示:
import java.util.ArrayList;
import java.util.Map;


/**
 * 类说明:利用LinkedHashMap实现简单的缓存, 必须实现removeEldestEntry方法,具体参见JDK文档
 * 
 * @author dennis
 * 
 * @param <K>
 * @param <V>
 */
public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {
    private final int maxCapacity;

    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    private final Lock lock = new ReentrantLock();

    public LRULinkedHashMap(int maxCapacity) {
        super(maxCapacity, DEFAULT_LOAD_FACTOR, true);
        this.maxCapacity = maxCapacity;
    }

    @Override
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
        return size() > maxCapacity;
    }
    @Override
    public boolean containsKey(Object key) {
        try {
            lock.lock();
            return super.containsKey(key);
        } finally {
            lock.unlock();
        }
    }

    
    @Override
    public V get(Object key) {
        try {
            lock.lock();
            return super.get(key);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public V put(K key, V value) {
        try {
            lock.lock();
            return super.put(key, value);
        } finally {
            lock.unlock();
        }
    }

    public int size() {
        try {
            lock.lock();
            return super.size();
        } finally {
            lock.unlock();
        }
    }

    public void clear() {
        try {
            lock.lock();
            super.clear();
        } finally {
            lock.unlock();
        }
    }

    public Collection<Map.Entry<K, V>> getAll() {
        try {
            lock.lock();
            return new ArrayList<Map.Entry<K, V>>(super.entrySet());
        } finally {
            lock.unlock();
        }
    }
}

    如果你去看LinkedHashMap的源码可知,LRU算法是通过双向链表来实现,当某个位置被命中,通过调整链表的指向将该位置调整到头位置,新加入的内容直接放在链表头,如此一来,最近被命中的内容就向链表头移动,需要替换时,链表最后的位置就是最近最少使用的位置。
    LRU算法还可以通过计数来实现,缓存存储的位置附带一个计数器,当命中时将计数器加1,替换时就查找计数最小的位置并替换,结合访问时间戳来实现。这种算法比较适合缓存数据量较小的场景,显然,遍历查找计数最小位置的时间复杂度为O(n)。我实现了一个,结合了访问时间戳,当最小计数大于MINI_ACESS时(这个参数的调整对命中率有较大影响),就移除最久没有被访问的项:
package net.rubyeye.codelib.util.concurrency.cache;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 
 * @author dennis 类说明:当缓存数目不多时,才用缓存计数的传统LRU算法
 * @param <K>
 * @param <V>
 */
public class LRUCache<K, V> implements Serializable {

    private static final int DEFAULT_CAPACITY = 100;

    protected Map<K, ValueEntry> map;

    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    private final Lock readLock = lock.readLock();

    private final Lock writeLock = lock.writeLock();

    private final volatile int maxCapacity;  //保持可见性

    public static int MINI_ACCESS = 5;

    public LRUCache() {
        this(DEFAULT_CAPACITY);
    }

    public LRUCache(int capacity) {
        if (capacity <= 0)
            throw new RuntimeException("缓存容量不得小于0");
        this.maxCapacity = capacity;
        this.map = new HashMap<K, ValueEntry>(maxCapacity);
    }

    public boolean ContainsKey(K key) {
        try {
            readLock.lock();
            return this.map.containsKey(key);
        } finally {
            readLock.unlock();
        }
    }

    public V put(K key, V value) {
        try {
            writeLock.lock();
            if ((map.size() > maxCapacity - 1) && !map.containsKey(key)) {
                // System.out.println("开始");
                Set<Map.Entry<K, ValueEntry>> entries = this.map.entrySet();
                removeRencentlyLeastAccess(entries);
            }
            ValueEntry new_value = new ValueEntry(value);
            ValueEntry old_value = map.put(key, new_value);
            if (old_value != null) {
                new_value.count = old_value.count;
                return old_value.value;
            } else
                return null;
        } finally {
            writeLock.unlock();
        }
    }

    /**
     * 移除最近最少访问
     */
    protected void removeRencentlyLeastAccess(
            Set<Map.Entry<K, ValueEntry>> entries) {
        // 最小使用次数
        long least = 0;
        // 访问时间最早
        long earliest = 0;
        K toBeRemovedByCount = null;
        K toBeRemovedByTime = null;
        Iterator<Map.Entry<K, ValueEntry>> it = entries.iterator();
        if (it.hasNext()) {
            Map.Entry<K, ValueEntry> valueEntry = it.next();
            least = valueEntry.getValue().count.get();
            toBeRemovedByCount = valueEntry.getKey();
            earliest = valueEntry.getValue().lastAccess.get();
            toBeRemovedByTime = valueEntry.getKey();
        }
        while (it.hasNext()) {
            Map.Entry<K, ValueEntry> valueEntry = it.next();
            if (valueEntry.getValue().count.get() < least) {
                least = valueEntry.getValue().count.get();
                toBeRemovedByCount = valueEntry.getKey();
            }
            if (valueEntry.getValue().lastAccess.get() < earliest) {
                earliest = valueEntry.getValue().count.get();
                toBeRemovedByTime = valueEntry.getKey();
            }
        }
        // System.out.println("remove:" + toBeRemoved);
        // 如果最少使用次数大于MINI_ACCESS,那么移除访问时间最早的项(也就是最久没有被访问的项)
        if (least > MINI_ACCESS) {
            map.remove(toBeRemovedByTime);
        } else {
            map.remove(toBeRemovedByCount);
        }
    }

    public V get(K key) {
        try {
            readLock.lock();
            V value = null;
            ValueEntry valueEntry = map.get(key);
            if (valueEntry != null) {
                // 更新访问时间戳
                valueEntry.updateLastAccess();
                // 更新访问次数
                valueEntry.count.incrementAndGet();
                value = valueEntry.value;
            }
            return value;
        } finally {
            readLock.unlock();
        }
    }

    public void clear() {
        try {
            writeLock.lock();
            map.clear();
        } finally {
            writeLock.unlock();
        }
    }

    public int size() {
        try {
            readLock.lock();
            return map.size();
        } finally {
            readLock.unlock();
        }
    }

    public long getCount(K key) {
        try {
            readLock.lock();
            ValueEntry valueEntry = map.get(key);
            if (valueEntry != null) {
                return valueEntry.count.get();
            }
            return 0;
        } finally {
            readLock.unlock();
        }
    }

    public Collection<Map.Entry<K, V>> getAll() {
        try {
            readLock.lock();
            Set<K> keys = map.keySet();
            Map<K, V> tmp = new HashMap<K, V>();
            for (K key : keys) {
                tmp.put(key, map.get(key).value);
            }
            return new ArrayList<Map.Entry<K, V>>(tmp.entrySet());
        } finally {
            readLock.unlock();
        }
    }

    class ValueEntry implements Serializable {
        private V value;

        private AtomicLong count;

        private AtomicLong lastAccess;

        public ValueEntry(V value) {
            this.value = value;
            this.count = new AtomicLong(0);
            lastAccess = new AtomicLong(System.nanoTime());
        }

        public void updateLastAccess() {
            this.lastAccess.set(System.nanoTime());
        }

    }
}
分享到:
评论

相关推荐

    list_lru.rar_Always

    1. **LRU算法原理**:LRU算法的核心是基于数据的访问频率来决定缓存中的数据何时被淘汰。当新数据需要被缓存且空间不足时,最近最少使用的数据将首先被移除。这种策略旨在尽可能保留最近频繁访问的数据,以提高性能...

    erlang lru cache module

    当需要淘汰元素时,LRU算法会选择最近最久未使用的元素进行删除。 6. **更新操作(Update)**:如果尝试获取的键已经存在于缓存中,可以更新其对应的值,同时更新访问时间。 7. **删除操作(Deletion)**:允许...

    iBATIS缓存的使用方法

    - 这是最简单的缓存实现方式,使用引用计数来管理缓存项。当一个缓存项的引用计数为零时,该项就会被移除。 - MEMORY缓存不支持统一的失效策略,适合对内存使用没有严格限制的场景。 2. **LRU ...

    lru.zip_show

    LRU算法的基本思想是:当内存满时,最近最少使用的数据会被优先淘汰。这个策略基于一个假设,即最近频繁使用的数据在未来也更可能被频繁访问,因此应尽可能保留在内存中。 在 "lru.c" 文件中,我们可以预期会看到...

    封装的高效缓存类,并模拟多个站点共享缓存

    2. **分布式哈希**:通过一致性哈希算法,将键均匀分布到不同的缓存节点,实现数据的负载均衡。 3. **事件通知**:当一个站点修改了缓存,其他站点需要知道这一变化,可以采用发布/订阅模式进行通信。 4. **数据复制...

    高性能Java数据库缓存_缓存思路

    1. 单个对象缓存:存储单条数据库记录,常用的数据结构如HashMap,配合LRU算法优化。 2. 列表缓存:例如论坛帖子列表,需要支持分页功能。 3. 长度缓存:记录集合的总数,用于实现分页显示。 4. 复杂查询缓存:如按...

    安卓图片加载缓存相关-andengine中直接加载多张小图片合成一张大图片生成动画精灵.rar

    同时,开发者也可以自定义缓存策略,例如使用LRU(最近最少使用)算法来决定何时移除不再使用的图片。 在合成大图片并创建动画精灵时,需要注意以下几点: 1. 图片的顺序:在`TextureAtlas`中,图片的顺序应与动画...

    计算机系统结构实验.doc

    在实验中, Cache 和主存的实现使用了结构体数组, CacheUpdate 结构体中包括 value、state 和 counter三个成员变量,分别表示 Cache 中的序列号、是否装入和计数器。table 数组用于保存整个 Cache 的更新情况,sort...

    Python实现的最近最少使用算法

    总之,Python实现的LRU算法通过结合字典和堆数据结构,能够有效地管理和淘汰缓存中的数据,适用于需要限制内存占用并优化性能的场景。例如,数据库查询结果缓存、文件系统缓存等,都可以利用这种机制提高效率。

    Oracle性能优化.doc

    - LRU算法在Buffercache中的应用。 - **5.1.5 脏块与脏LRU链的应用** - 脏块管理和脏LRU链的应用技巧。 **5.2 块的读** - 块读取操作及其优化方法。 **5.3 块的写** - **5.3.1 写脏块** - 写入脏块的过程及其...

    mybatis ehcache 整合中文文档

    - 合理设计缓存策略,如采用LRU(Least Recently Used)算法管理缓存。 - 调整缓存过期时间,根据业务需求灵活调整。 #### 六、总结 通过本文介绍的MyBatis与EHCache的整合方式,我们可以有效地利用缓存技术来提高...

    缓存:Swift缓存库

    1. 存储机制:缓存库会提供一个存储结构,如字典或者LRU(Least Recently Used)算法,用于决定何时清除不再使用的数据。 2. 缓存策略:包括时间过期策略、大小限制策略、最不常用策略等,以确保缓存不会过度消耗...

    DiskLruCache 源码和demo

    LRU算法是一种内存管理策略,当内存空间不足时,最近最少使用的数据会被优先淘汰。 DiskLruCache的工作原理: 1. **LRU算法**:LRU(Least Recently Used)是根据数据的历史访问记录来进行淘汰数据的。当缓存满时...

    mysql优化.txt

    - **缓存管理**:Key Cache采用LRU(Least Recently Used)算法来管理缓存中的索引块。这意味着最久未使用的索引块可能会被替换掉,以腾出空间给新的或最近频繁使用的索引块。 #### InnoDB 存储引擎的特点 InnoDB...

    android知识点整理

    - LRUCache是基于LRU(Least Recently Used)算法的缓存。 - DiskLruCache是基于磁盘的缓存。 8. **Bitmap的二次采样** - 尺寸压缩和质量压缩可以减少图片的大小,提高加载速度和降低内存消耗。 #### Android...

    详解Mybatis的二级缓存配置

    缓存将使用LRU(Least Recently Used)最近最少使用策略算法来回收。 缓存的配置可以通过缓存元素的属性来修改,例如,可以设置缓存的刷新间隔、缓存的大小、缓存的读写模式等。例如,可以设置缓存的刷新间隔为1...

    JetCache is a Java cache framework..zip

    2. **分布式缓存**:除了本地缓存,JetCache也支持与第三方分布式缓存系统集成,如Redis、Memcached等。这使得多节点应用能够共享同一份缓存数据,提高了数据一致性,并且可以通过缓存集群来扩展缓存容量。 3. **二...

    搜狐&&美团旅行面试题.docx

    递推公式为`dp[i] = max(dp[i-1], dp[i-2] + nums[i])`。 2. **2亿个QQ号,快速实现状态的设置** - 面对如此大规模的数据量,BitMap是一种非常节省空间的数据结构。每个QQ号的状态可以用一位二进制位表示,这样2...

    KJFrameForAndroid快速开发框架

    默认使用内存lru算法+磁盘lru算法缓存图片,同时节省内存消耗默认采用控件的大小作为图片的大小加载图片。 HttpLibrary模块 可以一行代码实现Http请求、一行代码实现文件或图片的上传与下载。 kjh.download( url, ...

    设计文档1

    采用页式存储,使用LRU算法进行页面替换,并且有独立的Cache类来管理内存。 2. 元数据管理模块:能创建、删除和修改表,以及数据库的创建、删除和切换。表元数据和数据库元数据均能持久化,并在启动时自动恢复。 3. ...

Global site tag (gtag.js) - Google Analytics