这个延迟加载缓存实现线程安全吗？

Question

I'm developing with the 3.5 .NET Framework and I need to use a cache in a multithread scenario with lazy-loading pattern for its items. After reading several articles on the web I've tried to write my own implementation.

public class CacheItem
{
    public void ExpensiveLoad()
    {
        // some expensive code
    }
}
public class Cache
{
    static object SynchObj = new object();
    static Dictionary<string, CacheItem> Cache = new Dictionary<string, CacheItem>();
    static volatile List<string> CacheKeys = new List<string>();

    public CacheItem Get(string key)
    {
        List<string> keys = CacheKeys;
        if (!keys.Contains(key))
        {
            lock (SynchObj)
            {
                keys = CacheKeys;
                if (!keys.Contains(key))
                {
                    CacheItem item = new CacheItem();
                    item.ExpensiveLoad();
                    Cache.Add(key, item);
                    List<string> newKeys = new List<string>(CacheKeys);
                    newKeys.Add(key);
                    CacheKeys = newKeys;
                }
            }
        }
        return Cache[key];
    }
}

As you can see the Cache object uses both a dictionary which stores the real key-value pairs and a list which duplicates only the keys. When a thread calls the Get method it reads the static shared key list (which is declared volatile) and call the Contains method to see if the key is already present and if not uses a double-checked lock pattern before starting the lazy loading. At the end of the loading a new instance of the key list is created and stored in the static variable.

Obviously I'm in a situation where the cost of recreating the entire list of keys is almost irrelevant against the cost of a single item loading.

I hope someone can tell me if it is really thread-safe. When I say "thread-safe" I mean that every reader thread can avoid corrupted or dirty reads and every writer thread loads the missing item only once.

Answer 1

This is not thread safe since you aren't locking when reading the Dictionary.

There is a race condition whereby one thread can be reading:

return Cache[key];

while another is writing:

_Cache.Add(key, item);

As the MSDN documentation for Dictionary<TKey,TValue> states: `

To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

and your synchorization does not include the reader.

You really need to use a thread-safe dictionary, which will simplify your code enormously (you won't need the List at all)

I'd recommend getting the source for the .NET 4 ConcurrentDictionary.

Getting thread safety right is hard, as is evidenced by the fact that some of the other answerers are incorrectly stating that your implementation is thread-safe. Hence I'd trust Microsoft's implementation before a home made one.

If you don't want to use a thread-safe dictionary, then I'd recommend something simple like:

public CacheItem Get(string key)
{
    lock (SynchObj)
    {
        CacheItem item;
        if (!Cache.TryGetValue(key, out item))
        {
            item = new CacheItem();
            item.ExpensiveLoad();
            Cache.Add(key, item);
        }
        return item;
    }
}

You could also try an implementation with a ReaderWriterLockSlim , though you might not get a significant performance improvement (google for ReaderWriterLockSlim performance).

As for an implementation using a ConcurrentDictionary, in most cases I would simply use something like:

static ConcurrentDictionary<string, CacheItem> Cache = 
    new ConcurrentDictionary<string, CacheItem>(StringComparer.Ordinal);
...
CacheItem item = Cache.GetOrAdd(key, key => ExpensiveLoad(key));

This can result in ExpensiveLoad being called more that once for each key, but I bet if you profile your app you'll find that this is so rare as to not be a problem.

If you really insist on ensuring it's only called once, then you could get hold of the .NET 4 Lazy<T> implementation and do something like:

static ConcurrentDictionary<string, Lazy<CacheItem>> Cache = 
    new ConcurrentDictionary<string, Lazy<CacheItem>>(StringComparer.Ordinal);
...

CacheItem item = Cache.GetOrAdd(key, 
               new Lazy<CacheItem>(()=> ExpensiveLoad(key))
             ).Value;

In this version, multiple Lazy<CacheItem> instances might be created, but only one will actually be stored in the dictionary. ExpensiveLoad will be called the first time Lazy<CacheItem>.Value is dereferenced for the instance stored in the dictionary. This Lazy<T> constructor uses LazyThreadSafetyMode.ExecutionAndPublication which uses a lock internally so ensure only one thread calls the factory method ExpensiveLoad .

As an aside, when constructing any dictionary with a string key, I always use the IEqualityComparer<string> parameter (usually StringComparer.Ordinal or StringComparer.OrdinalIgnoreCase) to explicitly document the intention regarding case-sensitivity.

Answer 2

So far i can't see any big issues. The only thing i can't see in your code is how do you make the CacheKeys public? The simplest one would be as IList<string> which is filled by a ReadOnlyCollection . This way your consumers can use index operators or the count property quite easily. In this case the volatile keyword should also not be needed cause you already put everything into your lock. So i would pimp your class as follows:

public class CacheItem
{
    public void ExpensiveLoad()
    {
        // some expensive code
    }
}
public class Cache
{
    private static object _SynchObj = new object();
    private static Dictionary<string, CacheItem> _Cache = new Dictionary<string, CacheItem>();
    private static ReadOnlyCollection<string> _CacheKeysReadOnly = new ReadOnlyCollection(new List<string>());

    public IList<string> CacheKeys
    {
        get
        {
            return _CacheKeysReadOnly;
        }
    }

    public CacheItem Get(string key)
    {
        CacheItem item = null;
        ReadOnlyCollection<string> keys = _CacheKeysReadOnly;
        if (!keys.Contains(key))
        {
            lock (_SynchObj)
            {
                keys = _CacheKeysReadOnly;
                if (!keys.Contains(key))
                {
                    item = new CacheItem();
                    item.ExpensiveLoad();
                    _Cache.Add(key, item);
                    List<string> newKeys = new List<string>(_CacheKeysReadOnly);
                    newKeys.Add(key);
                    _CacheKeysReadOnly = newKeys.AsReadOnly();
                }
            }
        }
        return item;
    }
}

As an alternative if you already on .Net 4.5 you could also think about using the IReadOnlyList<T> interface for the CacheKeys property.