Creating a Thread-Safe ConcurrentHashSet in Java 8

shaking hands, handshake, contract

Java 8 introduced a plethora of new features, and among them is the ability to create a thread-safe ConcurrentHashSet. Prior to Java 8, developers often resorted to workarounds to achieve this. In this article, we will delve deep into how Java 8 simplifies the creation of a ConcurrentHashSet and the advantages it offers.

Understanding Concurrent Collections in Java

Java's Concurrency API provides concurrent versions of popular Collection classes. For instance, we have CopyOnArrayList as an alternative to ArrayList, and ConcurrentHashMap for HashMap. However, a direct counterpart for HashSet, named ConcurrentHashSet, was conspicuously missing.

While CopyOnWriteArraySet is thread-safe, it's not apt for scenarios requiring a large thread-safe set. It's more suited for cases where the set size remains small and read operations significantly outnumber write operations.

The Evolution of ConcurrentHashSet in Java 8

Before Java 8, a common practice to mimic a ConcurrentHashSet was to use a ConcurrentHashMap with identical values for all keys. This approach, however, had its limitations. For instance, the resulting map couldn't be used where a set was expected.

Another method was to obtain a Set view from ConcurrentHashMap using the keySet() method. This returned a Set, but it had its own set of constraints. For instance, any modifications to the map would reflect in the Set. Additionally, adding new elements to this key set would result in an UnsupportedOperationException.

Java 8 addressed these challenges by introducing the newKeySet() method. This method returns a Set backed by a ConcurrentHashMap where all values are set to Boolean.TRUE. This Set allows the addition of new objects, making it a more flexible solution.

Java
ConcurrentHashMap<String, Integer> certificationCosts = new ConcurrentHashMap<>();
Set<String> concurrentHashSet = certificationCosts.newKeySet();

Furthermore, Java 8 added an overloaded keySet(default value) method. This method returns a Set view of the keys in the ConcurrentHashMap, using a common default value for any additions.

Java
ConcurrentHashMap<String, Integer> certificationCosts = new ConcurrentHashMap<>();
Set<String> concurrentHashSet = certificationCosts.keySet(246);

Java 8 ConcurrentHashSet in Practice

Here's a comprehensive example demonstrating the creation of a ConcurrentHashSet in Java 8:

Java
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashSetDemo {

    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> certificationCosts = new ConcurrentHashMap<>();
        certificationCosts.put("OCAJP", 246);
        certificationCosts.put("OCPJP", 246);
        certificationCosts.put("Spring Core", 200);

        Set<String> concurrentHashSet = certificationCosts.newKeySet();
        concurrentHashSet.add("OCEJWCD");
        concurrentHashSet.contains("OCEJWCD");
        concurrentHashSet.remove("OCEJWCD");

        Set<String> anotherConcurrentHashSet = certificationCosts.keySet(246);
        anotherConcurrentHashSet.add("Spring enterprise");
    }
}

Alternatives to ConcurrentHashSet

While Java 8 provides a straightforward way to create a ConcurrentHashSet, there are other methods to create thread-safe sets in Java. One such class is CopyOnWriteArraySet. It's similar to CopyOnWriteArrayList and is ideal for applications where the set size is small and read operations are predominant.

Conclusion

Java 8 has significantly simplified the creation of a ConcurrentHashSet, eliminating the need for workarounds. With the introduction of the newKeySet() and keySet(default value) methods, developers can now easily create thread-safe sets that are both flexible and efficient.

Author