Item Prefer concurrency utilities to wait and notify

Motivation

• Since Java 5, the platform has offered high-level concurrency utilities in the java.util.concurrent package.
• They replace the manual and complex use of wait and notify.
• They are safer and easier to use, reducing the likelihood of errors in concurrent code.

Concurrency Utilities in java.util.concurrent
Utility categories:

• Executor Framework: Thread management covered in Item 80.
• Concurrent collections: Thread-safe implementations of standard collections such as List, Queue and Map.
• Synchronizers: Coordination between threads, including CountDownLatch, Semaphore, CyclicBarrier, Exchanger and Phaser.

Competing Collections

Features:

• Internally synchronized for high performance.
• They do not allow exclusion of competing activity.
• Atomic operations like putIfAbsent increase security and usability. Example: Implementation of a thread-safe Map:

Map<String, String> map = new ConcurrentHashMap<>();
String result = map.putIfAbsent("key", "value");
if (result == null) {
    System.out.println("Valor inserido.");
} else {
    System.out.println("Chave já existente com valor: " + result);
}

Benefits:

• Replace synchronized collections (Collections.synchronizedMap).
• Significant improvement in the performance of competing applications.

Synchronizers
Purpose: Coordination between threads.

Example of common synchronizers:

• CountDownLatch: Single-use barrier for thread coordination.
• Semaphore: Control access to shared resources.
• CyclicBarrier: Synchronization at reusable barrier points.
• Phaser: Advanced and dynamic thread synchronization.

Practical Example: Concurrent Timing with CountDownLatch
Objective: Measure the execution time of several threads concurrently.

Implementation:

public static long time(Executor executor, int concurrency, Runnable action) throws InterruptedException {
    CountDownLatch ready = new CountDownLatch(concurrency);
    CountDownLatch start = new CountDownLatch(1);
    CountDownLatch done = new CountDownLatch(concurrency);

    for (int i = 0; i < concurrency; i++) {
        executor.execute(() -> {
            try {
                ready.countDown(); // Indica que está pronto
                start.await();     // Aguarda o sinal de início
                action.run();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                done.countDown(); // Indica que terminou
            }
        });
    }

    ready.await();   // Aguarda todas as threads ficarem prontas
    long startTime = System.nanoTime();
    start.countDown(); // Dispara o sinal de início
    done.await();     // Aguarda todas as threads finalizarem
    return System.nanoTime() - startTime;
}

Notes:

• Uses three latches: ready (indicates readiness), start (initial trigger) and done (finalization).
• Uses System.nanoTime to accurately measure time intervals.

Current practice with wait and notify
Only needed for legacy code maintenance.
Main rules:

1. Always use a loop when calling wait:

synchronized (lock) {
    while (!condition) {
        lock.wait();
    }
}

1. Test the condition before and after waiting.
2. Avoid dependence on notify, prefer notifyAll.

Conclusion

• Use competitive utilities whenever possible.
• They make code more readable, secure and efficient.
• Modern alternatives (like CyclicBarrier or Phaser) can replace wait and notify-based patterns

---

Examples from the book

The above is the detailed content of Item Prefer concurrency utilities to wait and notify. For more information, please follow other related articles on the PHP Chinese website!