Concurrent collections

As I already mentioned, situation that requires concurrent access to a collection is pretty often. Let's say that we have a map that is accessed by many threads.
Synchronizing it like this is not the best choice, as only one thread at a time will be able to access it.

	private Map<String, Integer> map = new HashMap<>();
	public Integer getKey(String key) {
	synchronized (map) {
	return map.get(key);
	}
	}

view raw MapWithSynchronizedBlock.java hosted with ❤ by GitHub

Another approach is useful only in a few cases.

private Map<String, Integer> map = Collections.synchronizedMap(new HashMap<String, Integer>());

view raw SynchronizedMap.java hosted with ❤ by GitHub

The factory method creates synchronized wrapper for our map that makes it thread-safe. However if we want to iterate over it, we still need a synchronization, otherwise it will throw ConcurrentModificationException when some other thread will modify it while we're iterating.

The better solution is to use ConcurrentMap 

private ConcurrentMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();

view raw ConcurrentMap.java hosted with ❤ by GitHub

It not only gives us a concurrent access, but we can also iterate over it without synchronization.

Let's imagine a situation that we need to put some value to the map, on a condition that it isn't there already.
Doing it that way is a wrong solution:

	// bad solution
	public void addEntryIfKeyDoesNotExist(String key, Integer value) {
	if (!map.containsKey(key)) {
	map.put(key, value);
	}
	}

view raw ConcurrentMapBadSolution.java hosted with ❤ by GitHub

After we check that the key is not there, another thread could put some entry to the map and we will override existing value. Basically our operation in this implementation is not atomic.
So should we add the synchronization? No, the ConcurrentMap provides a method that will make this operation atomic:

	public void addEntryIfKeyDoesNotExist(String key, Integer value) {
	map.putIfAbsent(key, value);
	}

view raw ConcurrentMapPutIfAbsent.java hosted with ❤ by GitHub

ConcurrentMap provides also other methods that are able to perform atomic replacement or removal of an entry, only if it is mapped to a specified value.
There are also a concurrent implementations of List and Set - CopyOnWriteArrayList and CopyOnWriteArraySet. Every mutative operation on them creates a new copy, so they should be used with a special care.