Why there is no ConcurrentHashSet against ConcurrentHashMap

Additional alternatives to the rescue

User, meet ConcurrentHashMap. ConcurrentHashMap, meet user.

Java 8+ concurrency with newKeySet

Fancy Java 8 or later? ConcurrentHashMap.newKeySet() is your new best friend. It lets you create a thread-safe set without breaking a sweat:

Set<String> concurrentSet = ConcurrentHashMap.newKeySet();
concurrentSet.add("alpha"); // First day of the rest of your life.


This method bestows a set backed by a ConcurrentHashMap, guaranteeing you full concurrency, without requiring manual synchronization.

Go Guava

For our friends who use Google's Guava libraries, I present to you Sets.newConcurrentHashSet(). It gives you a nifty way to whip up a thread-safe set:

Set<T> guavaConcurrentSet = Sets.newConcurrentHashSet(); // Look ma, no hands!


Need it sorted? We got it!

In cases where the input data needs sorting, the ConcurrentSkipListSet rides to the rescue:

Set<T> sortedConcurrentSet = new ConcurrentSkipListSet<>(); // Let's get organised!


This set helps you keep your set sorted in natural order, while also dealing with concurrency.

Let's dissect some concepts

ConcurrentHashSet's doppelgänger

Confused? Let me break it down. ConcurrentHashMap has already defeated its concurrency fears on your behalf. It has plotted and planned and poured in some atomic operations, just so you can sleep peacefully:

// Concurrent HashMap Operations
concurrentMap.putIfAbsent(key, value); // Can't touch this.
concurrentMap.computeIfPresent(key, (k, v) -> newValue); // Eye of the tiger.


Just latch on to the keys of this map, and there you have it, a set that inhales these concurrency traits without an identity crisis.

Why skip the ConcurrentHashSet?

Java has a Mr. MIYAGI thing going on: use what you have to solve new problems. There's no ConcurrentHashSet in Java because extending a ConcurrentHashMap is sufficient, neat and clean. Java doesn't like redundant code, and here's just another example of uncluttered, targeted functionality. This aids you (the developer) in finding consistent APIs based on a solid ConcurrentHashMap structure. Efficient, right?

Decoding newKeySet() and newSetFromMap

newKeySet() is an awesome Java 8+ go-to when you need a thread-safe set:

Set<T> set = ConcurrentHashMap.newKeySet(); // I got the keys, keys, keys


For those not on the Java 8 ship yet, Java's got your back with Collections.newSetFromMap:

Set<T> set = Collections.newSetFromMap(new ConcurrentHashMap<T, Boolean>()); // Like a boss!


Concurrency and consistency—Best friends in Java

Using newKeySet or newSetFromMap will get you a concurrent set that is safe, while reaping the benefits of the existing, reliable ConcurrentHashMap code. Java's write once, run anywhere promise holds true—safe operations in a concurrent environment are within grasp, without reinventing the wheel or bloating Java's APIs.

Remember, concurrency in Java is complex. But, the language lends you the tools to handle it with efficiency and elegance. Always opt for the standard, built-in solutions before you dive deep into creating cumbersome and potentially risky concurrency controls.