LRU算法 java实现

别人写的帖子,现转帖过来慢慢研究,原地址是http://bbs.itzk.com/thread-1461-1-1.html



最简单的LRU算法实现,就是利用Java的LinkedHashMap,覆写其中的removeEldestEntry(Map.Entry)


如下所示:
Java代码
import java.util.ArrayList;  
import java.util.Collection;  
import java.util.LinkedHashMap;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
import java.util.Map;  
  
  
/**
* 类说明:利用LinkedHashMap实现简单的缓存, 必须实现removeEldestEntry方法,具体参见JDK文档
*  
*  
* @param
* @param
*/  
public class LRULinkedHashMap extends LinkedHashMap {  
    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 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> getAll() {  
        try {  
            lock.lock();  
            return new ArrayList>(super.entrySet());  
        } finally {  
            lock.unlock();  
        }  
    }  
}  


如果你去看LinkedHashMap的源码可知,LRU算法是通过双向链表来实现,当某个位置被命中,通过调整链表的指向将该位置调整到头位置,新加入的内容直接放在链表头,如此一来,最近被命中的内容就向链表头移动,需要替换时,链表最后的位置就是最近最少使用的位置。
    LRU算法还可以通过计数来实现,缓存存储的位置附带一个计数器,当命中时将计数器加1,替换时就查找计数最小的位置并替换,结合访问时间戳来实现。这种算法比较适合缓存数据量较小的场景,显然,遍历查找计数最小位置的时间复杂度为O(n)。我实现了一个,结合了访问时间戳,当最小计数大于MINI_ACESS时(这个参数的调整对命中率有较大影响),就移除最久没有被访问的项:
Java代码
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;  
  
/**
*  
*类说明:当缓存数目不多时,才用缓存计数的传统LRU算法
* @param
* @param
*/  
public class LRUCache implements Serializable {  
  
    private static final int DEFAULT_CAPACITY = 100;  
  
    protected Map 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(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> 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> entries) {  
        // 最小使用次数  
        long least = 0;  
        // 访问时间最早  
        long earliest = 0;  
        K toBeRemovedByCount = null;  
        K toBeRemovedByTime = null;  
        Iterator> it = entries.iterator();  
        if (it.hasNext()) {  
            Map.Entry valueEntry = it.next();  
            least = valueEntry.getValue().count.get();  
            toBeRemovedByCount = valueEntry.getKey();  
            earliest = valueEntry.getValue().lastAccess.get();  
            toBeRemovedByTime = valueEntry.getKey();  
        }  
        while (it.hasNext()) {  
            Map.Entry 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> getAll() {  
        try {  
            readLock.lock();  
            Set keys = map.keySet();  
            Map tmp = new HashMap();  
            for (K key : keys) {  
                tmp.put(key, map.get(key).value);  
            }  
            return new ArrayList>(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());  
        }  
  
    }  
阅读更多
个人分类: java学习
想对作者说点什么? 我来说一句

LRU算法java实现

2016年12月09日 3KB 下载

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭