서버 요청과 풀 격리

import java.util.concurrent.ForkJoinPool;

public final class ClosedDedicatedPoolFailure {
    public static void main(String[] args) {
        ForkJoinPool analyticsPool = new ForkJoinPool(2);
        analyticsPool.close();
        analyticsPool.submit(() -> 42).join();
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.stream.IntStream;

public final class ConcurrentCommonPoolRequests {
    private static long cpuWork(int value) {
        long result = value;
        for (int round = 0; round < 200; round++) {
            result = (result * 1_103_515_245L + 12_345L) & 0x7fff_ffffL;
        }
        return result;
    }

    public static void main(String[] args) throws Exception {
        int requestCount = 4;
        CountDownLatch start = new CountDownLatch(1);
        try (ExecutorService requests = Executors.newFixedThreadPool(requestCount)) {
            List<Future<Long>> results = new ArrayList<>();
            for (int request = 0; request < requestCount; request++) {
                results.add(
                        requests.submit(
                                () -> {
                                    start.await();
                                    return IntStream.range(0, 5_000)
                                            .parallel()
                                            .mapToLong(ConcurrentCommonPoolRequests::cpuWork)
                                            .sum();
                                }));
            }
            start.countDown();

            long checksum = 0;
            for (Future<Long> result : results) {
                checksum ^= result.get();
            }
            System.out.println("completed=" + results.size());
            System.out.println("combined-checksum=" + checksum);
        }
    }
}

import java.time.Duration;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.TimeUnit;

public final class DedicatedAnalyticsPool implements AutoCloseable {
    private final ForkJoinPool pool;

    public DedicatedAnalyticsPool(int parallelism) {
        pool = new ForkJoinPool(parallelism);
    }

    public long score(List<Integer> values, Duration timeout) throws Exception {
        return pool.submit(
                        () ->
                                values.parallelStream()
                                        .mapToLong(value -> (long) value * value)
                                        .sum())
                .get(timeout.toMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public void close() {
        pool.shutdown();
        try {
            if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
                pool.shutdownNow();
            }
        } catch (InterruptedException exception) {
            pool.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) throws Exception {
        try (DedicatedAnalyticsPool analytics = new DedicatedAnalyticsPool(2)) {
            long result = analytics.score(List.of(1, 2, 3, 4, 5), Duration.ofSeconds(1));
            System.out.println("score=" + result);
        }
    }
}

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public final class ExplicitExecutorComposition {
    private record Summary(int activeUsers, int publishedPosts) {}

    public static void main(String[] args) {
        try (ExecutorService cpuPool = Executors.newFixedThreadPool(2)) {
            CompletableFuture<Integer> users =
                    CompletableFuture.supplyAsync(
                            () ->
                                    java.util.stream.IntStream.range(0, 10_000)
                                            .map(value -> value % 3 == 0 ? 1 : 0)
                                            .sum(),
                            cpuPool);
            CompletableFuture<Integer> posts =
                    CompletableFuture.supplyAsync(
                            () ->
                                    java.util.stream.IntStream.range(0, 8_000)
                                            .map(value -> value % 5 == 0 ? 1 : 0)
                                            .sum(),
                            cpuPool);

            Summary summary = users.thenCombine(posts, Summary::new).join();
            System.out.println(summary);
        }
    }
}

import java.time.Duration;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;

public final class VirtualThreadBlockingBoundary {
    private static String load(String key) throws InterruptedException {
        Thread.sleep(Duration.ofMillis(5));
        return key.toUpperCase();
    }

    public static void main(String[] args) throws Exception {
        List<String> keys = List.of("java", "stream", "pool");
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Callable<String>> calls =
                    keys.stream().<Callable<String>>map(key -> () -> load(key)).toList();
            List<String> values =
                    executor.invokeAll(calls).stream()
                            .map(
                                    future -> {
                                        try {
                                            return future.get();
                                        } catch (Exception exception) {
                                            throw new IllegalStateException(exception);
                                        }
                                    })
                            .toList();
            System.out.println(values);
        }
    }
}