Lru cache算法以及他的锁的问题

Lru cache codes:

1. use double linked list for LRU.

2. For the lock, Do we need to put Get operation in lock or not?

    For example:  2.1.  this.cache.TryGetValue(key, out entry); in method GetItem(...);

            2.2. this.cache.ContainsKey(key) in method AddItem(...).

  For 2.1. We have to put it witin lock. because in method TryGetValue(key, out entry), it is not thread-safe.

           when one thread is get the entry index; then another thread delete the entry from entries, it is possible that entries[i] will return another entry value.

  For 2.2. this.cache.ContainsKey(key), which is still not thread-safe. I put it out of lock{}, maybe there is some risk.(it is safe if we put it in lock{}).

// It is from https://referencesource.microsoft.com/#mscorlib/system/collections/generic/dictionary.cs  

using System;
using System.Collections.Generic;
using System.Text;

namespace LruCache_20170421
{
    public class LruCache<T>
    {
        public LruCache(int maxEntries)
        {
            if (maxEntries < 0)
            {
                throw new ArgumentOutOfRangeException("maxEntries", maxEntries, "maxEntries must be greater than or equal zero.");
            }
            this.maxEntries = maxEntries;
        }

        public bool LruCacheEnabled
        {
            get
            {
                return this.maxEntries > 0;
            }
        }

        public void AddItem(string key, T item)
        {
            if (!LruCacheEnabled)
            {
                throw new ApplicationException("LruCache is disabled.");
            }

            if (string.IsNullOrEmpty(key))
            {
                throw new ArgumentNullException("key", "Key cannot be null or empty.");
            }

            if (this.cache.ContainsKey(key))
            {
                return;
            }

            lock (this.cache)
            {
                if (!this.cache.ContainsKey(key))
                {
                    if (this.cache.Count >= maxEntries)
                    {
                        RemoveOldestEntry();
                    }

                    CacheEntry cacheEntry = new CacheEntry();
                    cacheEntry.Key = key;
                    cacheEntry.Item = item;

                    if (listEnd == null)
                    {
                        // set the first element in the list
                        cacheEntry.Previous = null;
                        cacheEntry.Next = null;

                        listHead = cacheEntry;
                        listEnd = cacheEntry;
                    }
                    else
                    {
                        AddElementToEnd(cacheEntry);
                    }

                    this.cache.Add(key, cacheEntry);
                }
            }
        }

        /// <summary>
        /// add the element to the end of the list
        /// </summary>
        /// <param name="cacheEntry"></param>
        private void AddElementToEnd(CacheEntry cacheEntry)
        {
            cacheEntry.Previous = listEnd;
            cacheEntry.Next = null;
            listEnd.Next = cacheEntry;
            listEnd = cacheEntry;
        }

        public T GetItem(string key, out bool cached)
        {
            if (!LruCacheEnabled)
            {
                throw new ApplicationException("LruCache is disabled.");
            }

            if (string.IsNullOrEmpty(key))
            {
                //Logger.LogInformation("Key cannot be null or empty.");
                cached = false;
                return default(T);
            }

            T item = default(T);
            CacheEntry entry;
            lock (this.cache)
            {
                cached = this.cache.TryGetValue(key, out entry);
                if (cached)
                {
                    item = entry.Item;

                    #region move the element to the end of the list
                    if (entry == listEnd)
                    {
                        return listEnd.Item;
                    }

                    if (entry == listHead)
                    {
                        // it is the head of the list

                        // remove from the head
                        listHead = entry.Next;
                        listHead.Previous = null;
                    }
                    else // entry.Previous!=null
                    {
                        // remove from the list
                        entry.Previous.Next = entry.Next;
                        entry.Next.Previous = entry.Previous;
                    }

                    // add to the end
                    AddElementToEnd(entry);

                    #endregion
                }
            }

            return item;
        }

        #region Private

        /// <summary>
        /// Remove the end entry, which is oldest.
        /// </summary>
        private void RemoveOldestEntry()
        {
            if (listHead == null) // cache is null.
            {
                return;
            }

            // remove the element in list head
            CacheEntry entryToRemove = listHead;
            string keyToRemove = entryToRemove.Key;

            if (entryToRemove.Next != null)
            {
                entryToRemove.Next.Previous = null;
            }

            listHead = entryToRemove.Next;
            if (listEnd == entryToRemove)
            {
                listEnd = listHead;
            }

            this.cache.Remove(keyToRemove);
        }

        private readonly Dictionary<string, CacheEntry> cache = new Dictionary<string, CacheEntry>();
        private readonly int maxEntries;
        private CacheEntry listHead; // element with the farest access time
        private CacheEntry listEnd; // element with the nearest access time

        private class CacheEntry
        {
            public string Key;
            public T Item;

            // double linked list
            public CacheEntry Previous; // point the element with the far access time
            public CacheEntry Next; // point the element with the near access time
        }

        #endregion

    }

}