Understanding Concurrent Collections

Introduction to Concurrent Collections

Welcome to Concurrent Collections in Java, an important step forward in your journey through Java's concurrent utilities. Previously, we covered synchronized collections, which ensure thread safety but can sometimes introduce bottlenecks. In this lesson, we explore concurrent collections, specifically designed for high-concurrency environments where performance and scalability are critical.

What You'll Learn

In this lesson, you will: Understand the limitations of synchronized collections and how concurrent collections address them. Learn about ConcurrentHashMap, a high-performance alternative to synchronized maps. Implement and manipulate concurrent collections in practical examples to grasp their benefits. By the end of this lesson, you’ll be able to confidently use concurrent collections to build thread-safe applications with better performance and scalability.

Why Switch to Concurrent Collections?

In earlier lessons, we focused on synchronized collections, which guarantee thread safety by using locks to control access. While effective for ensuring safe access, synchronized collections can slow down performance under heavy load due to their reliance on locking the entire collection. Concurrent collections, like ConcurrentHashMap, solve this issue by enabling concurrent reads and writes without locking the entire collection. This results in much better performance under high contention and offers a more scalable solution for multi-threaded applications.

Implementing ConcurrentHashMap

Let’s dive into an example using ConcurrentHashMap, a widely-used concurrent collection designed to handle multiple threads accessing and modifying a shared map simultaneously. Java import java.util.concurrent.ConcurrentHashMap; public class ConcurrentMapExample {private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); public void incrementCount(String key) {map.merge(key, 1, Integer::sum);} public void displayMap() {map.forEach((key, count) -> System.out.println(key + ": " + count));}} import java.util.concurrent.ConcurrentHashMap; public class ConcurrentMapExample {private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); public void incrementCount(String key) {map.merge(key, 1, Integer::sum);} public void displayMap() {map.forEach((key, count) -> System.out.println(key + ": " + count));}} The ConcurrentHashMap is initialized to provide a high-performance map for thread-safe operations. Unlike traditional synchronized maps, ConcurrentHashMap allows concurrent reads and updates without locking the entire map, improving scalability. The incrementCount method safely increments the count for a given key using the merge method, which ensures atomic updates by handling concurrency internally: If the key does not exist, it initializes the value to 1 . If the key already exists, it retrieves the current value and applies Integer::sum, adding 1 to it. This update occurs in a single atomic operation, preventing lost updates when multiple threads modify the same key. Thread-safe reads and writes are guaranteed in ConcurrentHashMap . It allows multiple threads to read and write simultaneously without blocking, unlike traditional synchronized maps. Updates to individual keys do not require locking the entire map, which ensures better performance and scalability, especially in highly concurrent environments.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Simulating Concurrent Updates

To see ConcurrentHashMap in action, we simulate concurrent updates by multiple threads in the following Main class:

Java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentMapExample map = new ConcurrentMapExample();

        // Thread 1: Increment the count for "apple"
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.incrementCount("apple");
            }
        });

        // Thread 2: Increment the count for "banana"
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.incrementCount("banana");
            }
        });

        // Start both threads and wait for them to finish
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        // Display the updated map
        map.displayMap();
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentMapExample map = new ConcurrentMapExample();

        // Thread 1: Increment the count for "apple"
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.incrementCount("apple");
            }
        });

        // Thread 2: Increment the count for "banana"
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.incrementCount("banana");
            }
        });

        // Start both threads and wait for them to finish
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        // Display the updated map
        map.displayMap();
    }
}

In this example, two threads (t1 and t2) are created to concurrently increment the count for "apple" and "banana" 1000 times each. ConcurrentHashMap ensures that these operations happen without conflicts. After both threads have finished executing, the map is displayed to show the final counts. This demonstrates how efficiently ConcurrentHashMap can handle concurrent updates.

Even under concurrent modifications, ConcurrentHashMap provides a thread-safe environment without the need for additional synchronization code. It optimizes performance in multi-threaded applications by allowing multiple threads to update the map concurrently, without locking the entire map, making it ideal for read-heavy or highly concurrent applications.