Question

I am working on a web-based medical application and need to create a small in-memory object cache. Here is my use-case.

We need to show list of requests submitted by people who need certain things (Blood, Kidney, etc.) and it’s not going to be a huge list as in a given day request for blood or anything else will be a limited one. Please take into account that we do not want to use any caching API as it would be an overkill. The idea is to create a Map and place it in the ApplicationContext.

The moment a new request is being placed by any person, we will update that Map in the Application context and the moment the request expires, we will remove them from the Map. We need to look into the following points additionally.

1. Need to set Max Element Limit.
2. If Max Limit reached, we should removed entry which was added first.
3. Take care of any Synchronized issues.

Please suggest what Data-structure should be used and what things to take care of while implementing this.

Answer 1

I believe LinkedHashMap is exactly what you need. You just need to override removeEldestEntry(…) method, and it will automatically remove old entries for you if the maximum capacity is reached. Something like:

import java.util.*;

class CacheMap<K,V> extends LinkedHashMap<K,V> {
    protected final int maxCapacity;
    public CacheMap(int maxCapacity) {
        this.maxCapacity = maxCapacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > maxCapacity;
    }
}

You could implement a more sophisticated logic, for example remove very old entries even if the max. capacity is not reached.

If synchronizing atomic map operations is enough for you, you can just wrap the map into Collections.synchronizedMap(…):

Map<K,V> map = Collections.synchronizedMap(new CacheMap<K,V>(capacity));

If you need more accurate synchronization, for example read the map and update it in one synchronized block, you need to synchronize (all) code blocks that work with the map yourself.