1

I've got a scenario where I require to cache information from a webapi temporarily when it is first called. With the same parameters this API can be called a few times a second.

Due to performance restrictions I don't want each call fetching the data and putting it into the memory cache so I've implemented a system with Semaphores to try and allow one thread to initialize the cache and then allow the rest to just query that cache.

I've stripped down the code to show an example of what i'm doing currently.

      private static MemoryCacher memCacher = new MemoryCacher();
      private static ConcurrentDictionary<string, Semaphore> dictionary = new ConcurrentDictionary<string, Semaphore>();              


      private async Task<int[]> DoAThing(string requestHash)
      {           
             // check for an existing cached result before hitting the dictionary
             var cacheValue = memCacher.GetValue(requestHash);
             if (cacheValue != null)
             {                      
                   return ((CachedResult)cacheValue).CheeseBurgers;
             }

             Semaphore semi;
             semi = dictionary.GetOrAdd(requestHash, new Semaphore(1, 1, requestHash));                  
             semi.WaitOne();

             //It's possible a previous thread has now filled up the cache. Have a squiz.
             cacheValue = memCacher.GetValue(requestHash);
             if (cacheValue != null)
             {                 
                    dictionary.TryRemove(requestHash);    
                    semi.Release();             
                    return ((CachedResult)cacheValue).CheeseBurgers;                           
             }

             // fetch the latest data from the relevant web api
             var response = await httpClient.PostAsync(url, content);                     

             // add the result to the cache
             memCacher.Add(requestHash, new CachedResult() { CheeseBurgers = response.returnArray }, DateTime.Now.AddSeconds(30));

             // We have added everything to the cacher so we don't need this semaphore in the dictonary anymore:
             dictionary.TryRemove(requestHash);

             //Open the floodgates
             semi.Release()


             return response.returnArray;
      }

Unfortunately there are many weird issues where more than one thread at a time manages to get through the WaitOne() call and then when released manages to break due to the count restriction on the semaphore. (to make sure only one semaphore is working at a time) I've tried using Mutexes and Monitors, but since IIS doesn't guarantee that an API call will always run on the same thread this causes it to fail regularly when the mutex is attempted to be released in a different thread.

Any suggestions on other ways to implement this would be welcome as well!

Nathan
  • 633
  • 7
  • 12
  • 1
    How about just use [`lock`](https://msdn.microsoft.com/en-us/library/c5kehkcz.aspx)? – John Saunders May 14 '15 at 04:54
  • Why not using thread safe collections? http://stackoverflow.com/questions/2980283/thread-safe-collections-in-net – JotaBe May 14 '15 at 08:08
  • JohnSaunders: Wanted to try and use asynchronous commands and you can't just slap a lock around those unfortunately. JotaBe: We are using a thread safe collection (ConcurrentDictionary) to store information (the semaphore object) across the threads, the memCacher itself is also thread-safe but we only want one thread writing to it at a time, blocking other threads from proceeding at all until an item shows up that it can use. – Nathan May 14 '15 at 19:46

0 Answers0