TreeMap and TreeSet Thread Safety

TreeMap and TreeSet are not thread-safe collections, so care must be taken to ensure when used in multi-threaded programs.

Both TreeMap and TreeSet are safe when read, even concurrently, by multiple threads. So if they have been created and populated by a single thread (say, at the start of the program), and only then read, but not modified by multiple threads, there’s no reason for synchronization or locking.

However, if read and modified concurrently, or modified concurrently by more than one thread, the collection might throw a ConcurrentModificationException or behave unexpectedly. In these cases, it’s imperative to synchronize/lock access to the collection using one of the following approaches:

1. Using Collections.synchronizedSorted..:

SortedSet<Integer> set = Collections.synchronizedSortedSet(new TreeSet<Integer>());
SortedMap<Integer,String> map = Collections.synchronizedSortedMap(new TreeMap<Integer,String>());

This will provide a SortedSet/SortedMap implementation backed by the actual collection, and synchronized on some mutex object. Note that this will synchronize all read and write access to the collection on a single lock, so even concurrent reads would not be possible.

1. By manually synchronizing on some object, like the collection itself:

TreeSet<Integer> set = new TreeSet<>(); 
...

//Thread 1
synchronized (set) {
 set.add(4);
}
...

//Thread 2
synchronized (set) {
 set.remove(5);
}

1. By using a lock, such as a ReentrantReadWriteLock:

TreeSet<Integer> set = new TreeSet<>(); 
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
...

//Thread 1
lock.writeLock().lock();
set.add(4);
lock.writeLock().unlock();
...  

//Thread 2
lock.readLock().lock();
set.contains(5);
lock.readLock().unlock();

As opposed to the previous synchronization methods, using a ReadWriteLock allows multiple threads to read from the map concurrently.