Two threads accessing same hashmap, one thread is continuously running other runs after 2 mins and clears that hashmap, how to handle this in java

Question

The first thread is of JMS subscriber that listens to a topic. As soon as it gets a message it adds/updates/deletes entries in a hashmap. Another thread runs after every 2 mins using TimerClass and reads the contents of the same hashmap and stores it in a file and clears the hashmap. Please suggest what kind of hashmap- concurrent or synchronized should be used? is there any other way to achieve this ?

Answer 1

Synchronization will be necessary. Since HashMap is not synchronized.

Use Collections.SynchronizedMap or move to Hashtable

Answer 2

The simplest and probably the most efficient solution would be to use a regular HashMap within a synchronized block. The writer would be as follows:

synchronized(mapLock)
{
  map.put(...)
}

The purging thread would then be able to simply replace the map with a new empty one:

Map oldMap; 
synchronized(mapLock)
{
  oldMap = map;
  map = new HashMap<...>();
}
store(oldMap);

This would ensure that the purging thread remains in the critical section for as short as possible.

Currently I can't see any advantage of using ConcurrentHashMap in this scenario. That could be different if multiple JMS threads would be running.

Answer 3

You can have the second thread atomically replace the hashmap with an empty new one, wait for a bit and store the data from the old one.

To make the "wait a bit" more precise, you can, if there's no clear upper limit to the processing time of one message, have the first thread lock the map for as long as it's using it. Then the second thread can acquire the lock before writing the contents, so that it's sure the first thread is done writing the last message's changes to the map.

Answer 4

How about simply swapping out the hash map? So thread 2 begins by setting the hashmap used by thread 1 to another and then does whatever it needs to do with thread 2. That way you won't have to deal with serialisation. so

storemap(){
 mapcopy=thread1.map;
 thread1.map=new Hashmap<Object>();
 store(mapcopy);
}