LRU最近最少使用缓存集合

       编码中涉及到资源管理就会经常使用到最近最少使用淘汰原理（LRU），比如说最近打开的文章列表管理、或者游戏中动态加载地图、音乐一样。使用LRU可以提高效率。本文实现了一个完整功能的LRU集合，可用于各种诸如此类需要缓存机制的地方。

    /// 

    /// 使用最近最少算法进行淘汰的缓存集合，用于缓存数据.
    /// 提供了多线程安全访问功能
    /// 
    ///     
    /// 1、调用方在每使用一个数据之后，调用UpdateRecentlyUsed函数将该数据
    /// 置为最近访问。函数会将该条目的读取权值设为最大值。
    /// 2、在使用Add或者Insert添加条目时，如果缓存数目已达到设定的CacheSize值，
    /// 则会根据删除掉缓存列表中读取权值最小的条目。再进行添加
    /// 
    public class LRUCacheList : IList
    {
        #region Property
        /// 

        /// 实际存放缓存条目的列表
        /// 
        private List m_listData;

        /// 

        /// 存放与m_listData依次对应条目的最近读取记录
        /// 
        private List m_listReadWeight;

        /// 

        /// 当前最大的读取记录权值，用来计算下一个读取值
        /// 
        private uint m_iMaxWeight;

        /// 

        /// 一个无符号整数的最大值
        /// 
        private const uint c_MaxWeight = 0xffffffff;

        private Object m_lockObj = new object();

        /// 

        /// 读取和设置缓存大小，指定最多缓存的对象数目
        /// 
        public int CacheSize { get; set; }
        #endregion

        #region Method

        /// 

        /// 
        /// 
        /// 缓存数目
        public LRUCacheList(int cacheSize)
        {
            m_listData = new List(cacheSize);
            m_listReadWeight = new List(cacheSize);
            CacheSize = cacheSize;
        }


        /// 

        /// 移除掉最近最少使用的条目
        /// 
        protected void RemoveLeastRecentlyUsed()
        {
            lock (m_lockObj)
            {
                uint min = c_MaxWeight;
                int minIndex = -1;

                for (int i = 0; i < m_listReadWeight.Count; i++)
                {
                    if (m_listReadWeight[i] < min)
                    {
                        min = m_listReadWeight[i];
                        minIndex = i;
                    }

                }

                if (minIndex != -1)
                {
                    m_listReadWeight.RemoveAt(minIndex);
                    m_listData.RemoveAt(minIndex);
                }
            }

        }


        /// 

        /// 更新指定位置的权重值为最近访问
        /// 
        /// 
        public void UpdateRecentlyUsed(T item)
        {
            lock (m_lockObj)
            {
                int index = m_listData.IndexOf(item);
                if (index != -1)
                    UpdateRecentlyUsed(index);
            }
        }

        /// 

        /// 更新指定位置的权重值为最近访问
        /// 
        /// 
        public void UpdateRecentlyUsed(int index)
        {
            m_listReadWeight[index] = NextMaxWeight();
        }

        /// 

        /// 清除掉所有缓存的内容
        /// 
        public void Clear()
        {
            lock (m_lockObj)
            {
                if (m_listData != null)
                    m_listData.Clear();

                if (m_listReadWeight != null)
                    m_listReadWeight.Clear();

                m_iMaxWeight = 0;
            }
        }

        /// 

        /// 获取并设置下一个最大的权重值
        /// 
        /// 
        public uint NextMaxWeight()
        {
            lock (m_lockObj)
            {
                //到达最大值重置
                if (m_iMaxWeight == c_MaxWeight - 1)
                {
                    m_iMaxWeight = 0;
                    for (int i = 0; i < m_listReadWeight.Count; i++)
                    {
                        m_listReadWeight[i] = 0;
                    }
                }
                m_iMaxWeight++;
                return m_iMaxWeight;
            }
        }

        /// 

        /// 添加一个条目并设置为最近访问
        /// 
        /// 
        public void AddRecently(T item)
        {
            lock (m_lockObj)
            {
                while (CacheSize > 0 && m_listData.Count >= CacheSize)
                    RemoveLeastRecentlyUsed();

                m_listData.Add(item);
                m_listReadWeight.Add(NextMaxWeight());
            }

        }

        /// 

        /// 插入一个条目并设置为最近访问
        /// 
        /// 
        /// 
        public void InsertRecently(int index, T item)
        {
            lock (m_lockObj)
            {
                while (CacheSize > 0 && m_listData.Count >= CacheSize)
                    RemoveLeastRecentlyUsed();

                m_listData.Insert(index, item);
                m_listReadWeight.Insert(index, NextMaxWeight());
            }
        }

        #endregion



        #region 实现IList 接口

        public void Add(T item)
        {
            lock (m_lockObj)
            {
                while (CacheSize > 0 && m_listData.Count >= CacheSize)
                    RemoveLeastRecentlyUsed();
                m_listData.Add(item);
                m_listReadWeight.Add(0);
            }
        }

        /// 

        /// 
        /// 
        /// 
        /// 

        public int IndexOf(T item)
        {
            return m_listData.IndexOf(item);
        }

        public void Insert(int index, T item)
        {
            lock (m_lockObj)
            {
                while (CacheSize > 0 && m_listData.Count >= CacheSize)
                    RemoveLeastRecentlyUsed();

                m_listData.Insert(index, item);
                m_listReadWeight.Insert(index, 0);
            }
        }

        public void RemoveAt(int index)
        {
            lock (m_lockObj)
            {
                m_listData.RemoveAt(index);
                m_listReadWeight.RemoveAt(index);
            }
        }

        public T this[int index]
        {
            get
            {
                return m_listData[index];
            }
            set
            {
                m_listData[index] = value;
            }
        }


        public bool Contains(T item)
        {
            return m_listData.Contains(item);
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            m_listData.CopyTo(array, arrayIndex);
        }

        public int Count
        {
            get { return m_listData.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public bool Remove(T item)
        {
            lock (m_lockObj)
            {
                int index = m_listData.IndexOf(item);
                if (index != -1)
                    m_listReadWeight.RemoveAt(index);
                return m_listData.Remove(item);
            }
        }

        public IEnumerator GetEnumerator()
        {
            return m_listData.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return m_listData.GetEnumerator();
        }
        #endregion

    }

　　

转载于:https://www.cnblogs.com/Kecp/archive/2012/12/02/2798579.html