LRU演算法簡單例子

package com.aspboy.base.cache;

/*
* Created on 2004-8-18
*
*“最近最少使用演算法”（LRU演算法），它是將最近一段時間內最少被訪問過的行淘汰出局。
*因此需要為每行設定一個計數器，LRU演算法是把命中行的計數器清零，其他各行計數器加1。
*當需要替換時淘汰行計數器計數值最大的資料行出局。
*這是一種高效、科學的演算法，其計數器清零過程可以把一些頻繁呼叫後再不需要的資料淘汰出Cache，
*提高Cache的利用率。
*/

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

/**
* @author 劉躍清
*
* 最近最少使用演算法 Window - Preferences - Java - Code Style - Code Templates
*/
public class LRU
{
protected HashMap lruCache = new HashMap(2);

//可操作的最大使用次數
protected int MAX_INTEGER_NUMBER=2147483647;

//快取中儲存的數大物件數目
protected int max_object_num=1000;

    public LRU()
    {
    }

    public LRU(int maxObjectNum)
    {
        max_object_num=maxObjectNum;
    }

    /**
     * 增加物件到快取中
     * @param key
     * @param value
     */
    public Object put(Object key, Object value)
    {
        CacheObject newValue = new CacheObject(value);
        if (lruCache.size()>=max_object_num)
        {
            removeLease();
        }

        return lruCache.put(key, newValue);
    }

    /**
     * 使用key來獲取物件
     *
     * @param key
     * @return
     */
    public Object get(Object key)
    {
        CacheObject object=(CacheObject)lruCache.get(key);
        if (object==null)
        {
            return null;
        }

        //根據LRU演算法原則，將命中的物件計算器0，將其他物件的計算值加1
        Set set=lruCache.keySet();
        Iterator iter=set.iterator();
        Object keyObject=null;
        CacheObject cacheObject=null;
        while(iter.hasNext())
        {
            keyObject=iter.next();
            cacheObject=(CacheObject) lruCache.get(keyObject);
            cacheObject.setUsetimes(cacheObject.getUsetimes()+1);
        }
        object.setUsetimes(0);

  return object!=null? object.getValue():null;
    }

    public boolean containsKey(Object key)
    {
        return lruCache.containsKey(key);
    }

    public void clear()
    {
        lruCache.clear();
    }

    public int size()
    {
        return lruCache.size();
    }

    public boolean isEmpty()
    {
        return lruCache.isEmpty();
    }

    public boolean containsValue(Object value)
    {
        return lruCache.containsKey(value);
    }

    /**
     * 移除使用最少的物件
     */
    public void removeLease()
    {
        Object leaseUseObjectKey=null;
        int usetimes=0;

        Set set=lruCache.keySet();
        Iterator iter=set.iterator();
        while(iter.hasNext())
        {
            Object keyObject=iter.next();
            CacheObject object=(CacheObject) lruCache.get(keyObject);
            if (object.getUsetimes()>usetimes)
            {
                usetimes=object.getUsetimes();
                leaseUseObjectKey=keyObject;
            }
        }
        lruCache.remove(leaseUseObjectKey);
    }

    public Set keySet()
    {
        return lruCache.keySet();
    }
    /**
     * 移除使用最頻繁的物件
     */
    public void removeMost()
    {
        Object leaseUseObjectKey=null;
        int usetimes=MAX_INTEGER_NUMBER;

        Set set=lruCache.keySet();
        Iterator iter=set.iterator();
        while(iter.hasNext())
        {
            Object keyObject=iter.next();
            CacheObject object=(CacheObject) lruCache.get(keyObject);
            if (object.getUsetimes()<usetimes)
            {
                usetimes=object.getUsetimes();
                leaseUseObjectKey=keyObject;
            }
        }
        lruCache.remove(leaseUseObjectKey);
    }

    /**
     * 移除最早置入快取的物件
     */
    public void removeEarly()
    {
        Object leaseUseObjectKey=null;
        long time=System.currentTimeMillis()+365*24*60*60*1000;

        Set set=lruCache.keySet();
        Iterator iter=set.iterator();
        while(iter.hasNext())
        {
            Object keyObject=iter.next();
            CacheObject object=(CacheObject) lruCache.get(keyObject);
            if (object.getPushtime()<time)
            {
                time=object.getPushtime();
                    leaseUseObjectKey=keyObject;
            }
        }
        lruCache.remove(leaseUseObjectKey);
    }

    /**
     * 移除最遲放入的物件
     */
    public void removeLater()
    {
        Object leaseUseObjectKey=null;
        long time=-1;

        Set set=lruCache.keySet();
        Iterator iter=set.iterator();
        while(iter.hasNext())
        {
            Object keyObject=iter.next();
            CacheObject object=(CacheObject) lruCache.get(keyObject);
            if (object.getPushtime()>time)
            {
                time=object.getPushtime();
                leaseUseObjectKey=keyObject;
            }
        }
        lruCache.remove(leaseUseObjectKey);
    }

    /**
     * 刪除某個鍵值及對應物件
     * @param key
     */
    public void remove(Object key)
    {
        lruCache.remove(key);
    }

    public static void main(String[] args)
    {
        LRU lru = new LRU(4);
        lru.put("a","The A String");
        lru.put("b","The B String");
        lru.put("d","The D String");
        lru.put("c","The C String");

        System.out.println(lru.toString());

        lru.get("a");
        lru.get("b");
        lru.get("d");
        lru.get("a");
        lru.get("b");
        lru.get("d");
        lru.put("e","The E String");
        lru.get("e");
        lru.get("e");
        lru.get("e");
        lru.get("e");
        System.out.println(lru.toString());
    }

    public String toString()
    {
        StringBuffer strBf= new StringBuffer(10);
        Set set1=lruCache.keySet();
        Iterator iter1=set1.iterator();
        while(iter1.hasNext())
        {
            Object key=iter1.next();
            strBf.append(key+"=");
            strBf.append(lruCache.get(key));
            strBf.append("/n");
        }
        return strBf.toString();
    }


}

package com.aspboy.base.cache;

/*
* Created on 2004-9-7
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
/**

*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class CacheObject
{
long pushtime = 0;

int usetimes = 0;

Object value = null;

    CacheObject( Object value )
    {
        pushtime = System.currentTimeMillis();
        usetimes = 0;
        this.value = value;
    }

    /**
     * @return Returns the pushtime.
     */
    public final long getPushtime()
    {
        return pushtime;
    }

    /**
     * @return Returns the usetimes.
     */
    public final int getUsetimes()
    {
        return usetimes;
    }
    /**
     * @param usetimes The usetimes to set.
     */
    public final void setUsetimes(int usetimes)
    {
        this.usetimes = usetimes;
    }
    /**
     * @return Returns the value.
     */
    public final Object getValue()
    {
        return value;
    }
    /**
     * @param value The value to set.
     */
    public final void setValue(Object value)
    {
        this.value = value;
    }

    public String toString()
    {
        StringBuffer strBf=new StringBuffer(10);
        strBf.append("value="+value+'/n');
        strBf.append("pushtime="+pushtime+'/n');
        strBf.append("usetimes="+usetimes+'/n');
        return strBf.toString();
    }
}

LRU演算法簡單例子

相關文章