使用ASP.Net缓存确保线程安全-两种策略的故事

Question

I have code that is not currently thread safe:

public byte[] GetImageByteArray(string filepath, string contentType, RImgOptions options)
{               
    //Our unique cache keys will be composed of both the image's filepath and the requested width
    var cacheKey = filepath + options.Width.ToString();
    var image = HttpContext.Current.Cache[cacheKey];

    //If there is nothing in the cache, we need to generate the image, insert it into the cache, and return it
    if (image == null)
    {
        RImgGenerator generator = new RImgGenerator();
        byte[] bytes = generator.GenerateImage(filepath, contentType, options);
        CacheItem(cacheKey, bytes);
        return bytes;
    }
    //Image already exists in cache, serve it up!
    else
    {
        return (byte[])image;
    }
}

My CacheItem() method checks to see if its max cache size has been reached, and if it has, it will start removing cached items:

//If the cache exceeds its max allotment, we will remove items until it falls below the max
while ((int)cache[CACHE_SIZE] > RImgConfig.Settings.Profile.CacheSize * 1000 * 1000)
{
    var entries = (Dictionary<string, DateTime>)cache[CACHE_ENTRIES];
    var earliestCacheItem = entries.SingleOrDefault(kvp => kvp.Value == entries.Min(d => d.Value));
    int length = ((byte[])cache[earliestCacheItem.Key]).Length;
    cache.Remove(earliestCacheItem.Key);
    cache[CACHE_SIZE] = (int)cache[CACHE_SIZE] - length;
}

Since one thread could remove an item from the cache as another thread is referencing it, I can think of two options:

Option 1: A lock

lock (myLockObject)
{
    if(image == null){ **SNIP** }
}

Option 2: Assign a shallow copy to a local variable

var image = HttpContext.Current.Cache[cacheKey] != null ? HttpContext.Current.Cache[cacheKey].MemberwiseClone() : null;

Both of these options have overhead. The first forces threads to enter that code block one at a time. The second necessitates creating a new object in memory which could be of non-trivial size.

Are there any other strategies I could employ here?

Answer 1

To provide pure consistency of your cache solution you should lock your resource while slowing down the application.

In general, you should try to provide caching strategy, based on your application logic.

• Check sliding window caching: while item which is older when some time span - will reduce locking of different threads - good when you have large spread of different cached items which not for sure will be used again.
• Consider using least frequently used strategy: the item that is least used should be removed while reached max cache size - best serves while you have multiple client hitting frequently same part of cached content.

Just check which one more suites better your type of BL and use it. It will not remove the locking issue at all, but right choice will significantly remove racing conditions.

In order to reduce shared resource between different threads, use read and write locks on each item and not on entire collection. This will boost your performance as well.

Another point of consideration that should be kept in mind - what if content of image with the same path is changed physically on the disk (different image was saved with the same name) while having this image already cached there is a chance of mistakenly provide not relevant data.

Hope it helped.