Should I use HashTable or HashMap as a data cache?

Question

I want to create a cache of data in memory, so that I do not have to query the database everytime.

The dictionary will initially be empty, and it will be populated as data is requested from it.

For this purpose, should the dictionary be a HashTable or a HashMap?

Will ConcurrentHashMap or synchronizedMap be better?

Please explain why X is better than Y for my purpose. I am trying to understand the differences between them.

//variable for locking purposes.
private String LOCK = new String("LOCK");
//HashMap or HashTable?
private HashMap<Long, Long> dictionary = new HashMap<Long, Long>();

public Long getValue(Long key) throws SQLException{
        Long value = dictionary.get(key);
        if(value != null)
            return value ;
        synchronized (LOCK) {
            //Check again to make sure another thread hasn't populated the dictionary
            key = dictionary.get(key);
            if(key != null)
                return value;
            //Get value  from database
            //store in map for future use
            dictionary.put(key, value);
        }
        return value;
    }

Since I want multiple threads to read data simultaneously, I am not synchronizing the entire method. However, inserting data into the dictionary should be synchronized.

I will not be storing null values.

P.S. Could someone explain the differences between them WITH EXAMPLES?

Solution 1

Use ConcurrentHashMap

It provides high-performance concurrent implementation of the standard Map interface.

To provide high concurrency, the implementation manages its own synchronization internally. So, it is impossible to exclude concurrent activity from it, locking it will have no effect but to slow the program.

ConcurrentHashMap is optimized for retrieval operations, such as get. ConcurrentHashMap extends Map and adds several methods, including putIfAbsent(key, value), which inserts a mapping for a key if none was present and returns the previous value associated with the key, or null if there was none. This makes it easy to implement thread-safe maps.

Besides offering excellent concurrency, ConcurrentHashMap is very fast. Unless you have a compelling reason to do otherwise, use ConcurrentHashMap in preference to Collections.synchronizedMap or Hashtable. Simply replacing old-style synchronized maps with concurrent maps can dramatically increase the performance of concurrent applications.

For more information I would suggest reading Effective Java.

Solution 2

Why don't you look at a cache API like ehcache (http://ehcache.org/). Also if your data is growing to Gigabyte level, then you can even link up with BigMemory.