Java Multithreading Cheat Sheet

// Extending Threadclass MyThread extends Thread {    @Override    public void run() { System.out.println("Running in " + getName()); }}new MyThread().start(); // never call run() directly - start() spawns a new thread// Implementing Runnable (preferred - allows extending other classes)Runnable task = () -> System.out.println("Task running");Thread t = new Thread(task);t.start();t.join(); // wait for thread to finish

ExecutorService pool = Executors.newFixedThreadPool(4);Future<Integer> future = pool.submit(() -> {    Thread.sleep(100);    return 42;});try {    Integer result = future.get(); // blocks until the result is ready} catch (InterruptedException | ExecutionException e) {    e.printStackTrace();}pool.shutdown(); // stop accepting new tasks, let running ones finish

class Counter {    private int count = 0;    public synchronized void increment() { // intrinsic lock on 'this'        count++;    }}// Explicit lock for more controlprivate final ReentrantLock lock = new ReentrantLock();public void safeUpdate() {    lock.lock();    try {        // critical section    } finally {        lock.unlock(); // always unlock in finally    }}// Atomic classes avoid locking entirely for simple countersprivate final AtomicInteger atomicCount = new AtomicInteger(0);atomicCount.incrementAndGet();

CompletableFuture<String> future = CompletableFuture    .supplyAsync(() -> fetchUser(1))       // runs on ForkJoinPool.commonPool() by default    .thenApply(user -> user.getName())    .thenApply(String::toUpperCase)    .exceptionally(ex -> "UNKNOWN");        // fallback on errorfuture.thenAccept(System.out::println); // consume the final resultCompletableFuture<Void> all = CompletableFuture.allOf(future1, future2); // wait for all

// One virtual thread per task - can create millions without exhausting OS threadstry (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {    List<Future<String>> futures = IntStream.range(0, 100_000)        .mapToObj(i -> executor.submit(() -> {            Thread.sleep(Duration.ofMillis(10)); // blocking calls are cheap - carrier thread is freed            return "task-" + i;        }))        .toList();    for (Future<String> f : futures) {        f.get();    }} // executor auto-closes and awaits termination// Virtual threads are daemon by default and NOT pooled - create freely, don't reuse

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {    Future<String> user = scope.fork(() -> fetchUser(userId));    Future<List<Order>> orders = scope.fork(() -> fetchOrders(userId));    scope.join();           // wait for both, or until first failure    scope.throwIfFailed();  // propagate any subtask exception    return new Profile(user.resultNow(), orders.resultNow());} // scope.close() ensures no forked thread outlives this block

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();private final Map<String, String> cache = new HashMap<>();public String read(String key) {    rwLock.readLock().lock();       // multiple readers allowed concurrently    try { return cache.get(key); }    finally { rwLock.readLock().unlock(); }}public void write(String key, String value) {    rwLock.writeLock().lock();      // exclusive - blocks readers and writers    try { cache.put(key, value); }    finally { rwLock.writeLock().unlock(); }}// StampedLock adds an optimistic read mode - faster when writes are rareprivate final StampedLock stamped = new StampedLock();public double distanceFromOrigin(double x, double y) {    long stamp = stamped.tryOptimisticRead();    double curX = x, curY = y;    if (!stamped.validate(stamp)) { // a write happened concurrently, fall back to a real lock        stamp = stamped.readLock();        try { curX = x; curY = y; } finally { stamped.unlockRead(stamp); }    }    return Math.sqrt(curX * curX + curY * curY);}

// CPU-bound work: size pool close to available coresExecutorService cpuPool = Executors.newFixedThreadPool(    Runtime.getRuntime().availableProcessors());// I/O-bound work (blocking calls): larger pool, or better, use virtual threadsExecutorService ioPool = new ThreadPoolExecutor(    10, 50,                          // core, max pool size    60L, TimeUnit.SECONDS,           // idle thread keep-alive    new LinkedBlockingQueue<>(200),  // bounded queue - avoid unbounded (OOM risk)    new ThreadPoolExecutor.CallerRunsPolicy() // backpressure: caller runs the task itself);// Avoid Executors.newCachedThreadPool() in production without limits -// it grows unbounded under load and can exhaust system resources

CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> fetchUser(id));CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() -> fetchOrders(id));CompletableFuture<Profile> profileFuture = userFuture    .thenCombine(ordersFuture, (user, orders) -> new Profile(user, orders));// anyOf races several futures, resolving with whichever finishes firstCompletableFuture<Object> fastest = CompletableFuture.anyOf(mirrorA, mirrorB, mirrorC);// Custom executor avoids starving the shared ForkJoinPool.commonPool()ExecutorService dedicated = Executors.newFixedThreadPool(8);CompletableFuture.supplyAsync(() -> fetchUser(id), dedicated)    .thenApplyAsync(User::getName, dedicated);