Dealing with concurrency issues when caching for high-traffic sites

Question 1

The problem you were asked on the interview is the so-called Cache miss-storm - a scenario in which a lot of users trigger regeneration of the cache, hitting in this way the DB.

To prevent this, first you have to set soft and hard expiration date. Lets say the hard expiration date is 1 day, and the soft 1 hour. The hard is one actually set in the cache server, the soft is in the cache value itself (or in another key in the cache server). The application reads from cache, sees that the soft time has expired, set the soft time 1 hour ahead and hits the database. In this way the next request will see the already updated time and won't trigger the cache update - it will possibly read stale data, but the data itself will be in the process of regeneration.

Next point is: you should have procedure for cache warm-up, e.g. instead of user triggering cache update, a process in your application to pre-populate the new data.

The worst case scenario is e.g. restarting the cache server, when you don't have any data. In this case you should fill cache as fast as possible and there's where a warm-up procedure may play vital role. Even if you don't have a value in the cache, it would be a good strategy to "lock" the cache (mark it as being updated), allow only one query to the database, and handle in the application by requesting the resource again after a given timeout

Question 2

You could probably be better of using some distributed cache repository, as memcached, or others depending your access pattern. You could use the Cache implementation of Google's Guava library if you want to store the values inside the application. From the coding point of view, you would need something like

public V get(K key){
    V value = map.get(key);
    if (value == null) {
        synchronized(mutex){
            value = map.get(key);
            if (value == null) {
                value = db.fetch(key);
                map.put(key, value);
            }
        }
    }
    return value;
}

where the map is a ConcurrentMap and the mutex is just

private static Object mutex = new Object();

In this way, you will have just one request to the db per missing key.

Hope it helps! (and don't store null's, you could create a tombstone value instead!)

Question 3

Cache miss-storm or Cache Stampede Effect, is the burst of requests to the backend when cache invalidates.

All high concurrent websites I've dealt with used some kind of caching front-end. Bein Varnish or Nginx, they all have microcaching and stampede effect suppression.

Just google for Nginx micro-caching, or Varnish stampede effect, you'll find plenty of real world examples and solutions for this sort of problem.

All boils down to whether or not you'll allow requests pass through cache to reach backend when it's in Updating or Expired state.

Usually it's possible to actively refresh cache, holding all requests to the updating entry, and then serve them from cache.

But, there is ALWAYS the question "What kind of data are you supposed to be caching or not", because, you see, if it is just plain text article, which get an edit/update, delaying cache update is not as problematic than if your data should be exactly shown on thousands of displays (real-time gaming, financial services, and so on).

So, the correct answer is, microcache, suppression of stampede effect/cache miss storm, and of course, knowing which data to cache when, how and why.

Question 4

It is worse to consider particular data type for caching only if data consumers are ready for getting stale date (in reasonable bounds).

In such case you could define invalidation/eviction/update policy to keep you data up-to-date (in business meaning).

On update you just replace data item in cache and all new requests will be responsed with new data

Example: Stocks info system. If you do not need real-time price info it is reasonable to keep in cache stock and update it every X mils/secs with expensive remote call.

Question 5

Do you really need to expire the cache. Can you have an incremental update mechanism using which you can always increment the data periodically so that you do not have to expire your data but keep on refreshing it periodically.

Secondly, if you want to prevent too many users from hiting the db in one go, you can have a locking mechanism in your stored proc (if your db supports it) that prevents too many people hitting the db at the same time. Also, you can have a caching mechanism in your db so that if someone is asking for the exact same data from the db again, you can always return a cached value

Some applications also use a third service layer between the application and the database to protect the database from this scenario. The service layer ensures that you do not have the cache miss storm in the db

Question 6

The answer is to never expire the Cache and have a background process update cache periodically. This avoids the wait and the cache-miss storms, but then why use cache in this scenario?

If your app will crash with a "Cache miss" scenario, then you need to rethink your app and what is cache verses needed In-Memory data. For me, I would use an In Memory database that gets updated when data is changed or periodically, not a Cache at all and avoid the aforementioned scenario.