join과 완료 가시성

import java.util.concurrent.CountDownLatch;

public final class ReadBeforeJoinBug {
    private static final class ResultTask implements Runnable {
        private final CountDownLatch gate;
        int result;

        ResultTask(CountDownLatch gate) {
            this.gate = gate;
        }

        public void run() {
            try {
                gate.await();
                result = 42;
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch gate = new CountDownLatch(1);
        ResultTask task = new ResultTask(gate);
        Thread worker = new Thread(task, "result-worker");
        worker.start();
        System.out.println("wrong-read=" + task.result);
        gate.countDown();
        worker.join();
        System.out.println("after-join=" + task.result);
    }
}

public final class ParallelStartThenJoin {
    public static void main(String[] args) throws InterruptedException {
        long[] values = new long[3];
        Thread[] workers = new Thread[3];
        for (int i = 0; i < workers.length; i++) {
            int slot = i;
            workers[i] =
                    new Thread(
                            () -> values[slot] = sum(slot * 1000 + 1, (slot + 1) * 1000),
                            "sum-" + slot);
        }
        for (Thread worker : workers) {
            worker.start();
        }
        for (Thread worker : workers) {
            worker.join();
        }
        long total = 0;
        for (long value : values) {
            total += value;
        }
        System.out.println("total=" + total);
    }

    private static long sum(int from, int to) {
        long result = 0;
        for (int n = from; n <= to; n++) {
            result += n;
        }
        return result;
    }
}

import java.util.List;

public final class DocumentBuildJoin {
    private record Result(String path, int headings) {}

    public static void main(String[] args) throws InterruptedException {
        List<String> paths = List.of("java/thread", "java/memory", "java/lock");
        Result[] results = new Result[paths.size()];
        Thread[] builders = new Thread[paths.size()];
        for (int i = 0; i < paths.size(); i++) {
            int slot = i;
            builders[i] = new Thread(() -> results[slot] = build(paths.get(slot)), "build-" + slot);
            builders[i].start();
        }
        for (Thread builder : builders) {
            builder.join();
        }
        int headings = 0;
        for (Result result : results) {
            System.out.println(result);
            headings += result.headings();
        }
        System.out.println("heading-total=" + headings);
    }

    private static Result build(String path) {
        return new Result(path, path.length() % 5 + 2);
    }
}

public final class JoinCancellationPolicy {
    public static void main(String[] args) {
        Thread worker =
                new Thread(
                        () -> {
                            try {
                                Thread.sleep(20);
                            } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();
                            }
                        },
                        "short-work");
        worker.start();
        boolean completed = joinOrCancel(worker);
        System.out.println("completed=" + completed + ", alive=" + worker.isAlive());
    }

    private static boolean joinOrCancel(Thread worker) {
        try {
            worker.join();
            return true;
        } catch (InterruptedException e) {
            worker.interrupt();
            Thread.currentThread().interrupt();
            return false;
        }
    }
}