Future 취소·시간 초과·실패

import java.util.concurrent.Executors;

public final class UncooperativeCancellation {
    public static void main(String[] args) throws Exception {
        var executor = Executors.newSingleThreadExecutor();
        var future = executor.submit(() -> {
            for (int i = 0; i < 5; i++) {
                try { Thread.sleep(50); }
                catch (InterruptedException ignored) { }
                System.out.println("step=" + i);
            }
        });
        Thread.sleep(20);
        System.out.println("cancelled=" + future.cancel(true));
        executor.shutdown();
        executor.awaitTermination(1, java.util.concurrent.TimeUnit.SECONDS);
    }
}

import java.time.Duration;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public final class CooperativeSearch {
    static int search(int target) throws InterruptedException {
        for (int candidate = 0; candidate < Integer.MAX_VALUE; candidate++) {
            if ((candidate & 0x3fff) == 0 && Thread.interrupted()) {
                throw new InterruptedException("search cancelled");
            }
            if (candidate == target) return candidate;
        }
        return -1;
    }

    public static void main(String[] args) throws Exception {
        var executor = Executors.newSingleThreadExecutor();
        var future = executor.submit(() -> search(Integer.MAX_VALUE - 1));
        try {
            System.out.println(future.get(Duration.ofMillis(5).toNanos(), TimeUnit.NANOSECONDS));
        } catch (TimeoutException e) {
            future.cancel(true);
            try { future.get(); }
            catch (CancellationException cancelled) { System.out.println("cancelled"); }
        } finally {
            executor.shutdownNow();
        }
    }
}

import java.time.Duration;
import java.util.concurrent.*;

public final class FutureOutcomeClassifier {
    sealed interface Outcome<T> permits Success, Failed, TimedOut, Cancelled {}
    record Success<T>(T value) implements Outcome<T> {}
    record Failed<T>(Throwable cause) implements Outcome<T> {}
    record TimedOut<T>() implements Outcome<T> {}
    record Cancelled<T>() implements Outcome<T> {}

    static <T> Outcome<T> await(Future<T> future, Duration timeout) throws InterruptedException {
        try {
            return new Success<>(future.get(timeout.toNanos(), TimeUnit.NANOSECONDS));
        } catch (TimeoutException e) {
            return new TimedOut<>();
        } catch (CancellationException e) {
            return new Cancelled<>();
        } catch (ExecutionException e) {
            return new Failed<>(e.getCause());
        }
    }

    public static void main(String[] args) throws Exception {
        var executor = Executors.newSingleThreadExecutor();
        try {
            Future<Integer> failed = executor.submit(() -> {
                throw new IllegalStateException("boom");
            });
            System.out.println(await(failed, Duration.ofSeconds(1)));
        } finally {
            executor.shutdownNow();
        }
    }
}