[JAVA] Item 81: Prefer concurrency utilities to wait and notify

81 Choose concurrency utility from wait and notify

• Since Java5, the processing that was previously done with wait and notify can now be done with a high-level concurrency utility. These should be used instead.
• High-level concurrency utilities can be divided into three parts.
• Executor framework (Item80)
• concurrent collection. This is the one implemented in List, Map, and Queue so that parallel processing can be performed well. These are internally synchronized, so locking them simply slows down the process. This part is suitable for state-dependent modify operations. With the advent of concurrent collections, synchronized collections have become a payment box.
• synchronizers. synchronizers enables movements emphasized by others, such as waiting for the processing of other threads to complete. Famous ones are CountDownLatch, Semaphore, CyclicBarrier, Exchanger and Phaser.
• The code using CountDownLatch is as follows. To explain the time method, when ready is countedDown three times, the ready await is solved, startNanos is measured, start countDown is done once, action is run, and each thread is done countDown. Then, if all three count down, done await is solved and the time taken is returned. This method does not end if the number of threads is less than the number specified in the second argument (thread starvation deadlock).

package tryAny.effectiveJava;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        Executor e = Executors.newFixedThreadPool(3); //If the argument here is less than the value of the second argument of time, the process will not end.

        System.out.println(time(e, 3, () -> System.out.println("a")));

    }

    // Simple framework for timing concurrent execution
    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(() -> {
                ready.countDown(); // Tell timer we're ready
                try {
                    start.await(); // Wait till peers are ready
                    action.run();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    done.countDown(); // Tell timer we're done
                }
            });
        }
        ready.await(); // Wait for all workers to be ready
        long startNanos = System.nanoTime();
        start.countDown(); // And they're off!
        done.await(); // Wait for all workers to finish
        return System.nanoTime() - startNanos;

    }
}

• We no longer see wait and notify in the newly written code. You may see it in the maintenance of legacy code.
• If you just write a summary about wait and notify,
• use wait in a while loop.
• You should use notifyAll rather than notify. When using notify, you must be careful about thread survival.