java-async-concurrent

name	java-async-concurrent
description	5 async/concurrent patterns with full Java implementations for high-performance systems
version	1.0.0
category	toolchain
author	Claude MPM Team
license	MIT
progressive_disclosure	{"entry_point":{"summary":"Java async/concurrent patterns: Virtual Threads, CompletableFuture, Reactive Streams, Thread Pool, Resilience4j","when_to_use":"When implementing concurrent, async, or resilient systems in Java 21+","quick_start":"Each pattern includes full implementation, key principles, and when to use vs alternatives"}}
context_limit	700
tags	["java","async","concurrent","virtual-threads","completable-future","reactive","project-reactor","thread-pool","resilience4j","retry"]
requires_tools	[]

Java Async/Concurrent Patterns

Async/Concurrent Patterns

1. Virtual Threads (Java 21)

// Pattern: Virtual threads for high concurrency
import java.time.*;
import java.util.concurrent.*;
import java.util.*;

public class VirtualThreadPatterns {
    /**
     * Process tasks concurrently using virtual threads.
     * Virtual threads are lightweight (millions possible) and perfect for I/O.
     *
     * Key Difference from Platform Threads:
     * - Platform threads: ~1MB stack, thousands max, pooled with ExecutorService
     * - Virtual threads: ~1KB stack, millions possible, no pooling needed
     */
    public static <T> List<T> processConcurrentTasks(
            List<Callable<T>> tasks,
            Duration timeout
    ) throws InterruptedException, ExecutionException, TimeoutException {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<T>> futures = executor.invokeAll(
                tasks,
                timeout.toMillis(),
                TimeUnit.MILLISECONDS
            );

            List<T> results = new ArrayList<>();
            for (Future<T> future : futures) {
                if (!future.isCancelled()) {
                    results.add(future.get()); // May throw ExecutionException
                }
            }

            return results;
        }
    }

    /**
     * Create virtual thread directly (Java 21+)
     */
    public static void runAsyncTask(Runnable task) {
        Thread.startVirtualThread(task);
    }

    // Virtual Threads Key Principles:
    // 1. Use for I/O-bound workloads (network calls, database queries)
    
    
    
    
}