Lessons

How to parallelise tasks and merge results with CompletableFuture: combining two results via thenCombine/ thenCombineAsync, waiting for a set of tasks with allOf, reacting to the fastest response with anyOf. We’ll examine signatures, practical examples with supplyAsync, non-blocking handling ( thenAccept, thenRun), as well as error nuances and handling ( exceptionally, handle, whenComplete). At the end — a compact comparison table of the methods.

How to safely catch and handle exceptions in CompletableFuture chains: we examine the roles of exceptionally (fallback value on error), handle (universal success/error handler), and whenComplete (side effects without changing the result). We will discuss why directly calling get()/ join() wraps causes in ExecutionException/ CompletionException, how to combine stages ( thenApply, thenAccept), and which common mistakes to avoid.

How to properly “glue” asynchronous steps in CompletableFuture using thenCompose and when thenApply is sufficient; how and why to plug in your own thread pool via ExecutorService (instead of ForkJoinPool.commonPool()); how to protect chains from “waiting forever” using orTimeout and completeOnTimeout. At the end — a practical example with a custom Executor, thenCompose, and a timeout, plus typical mistakes and their fixes.

In this lecture we cover asynchronous input/output (AIO) in Java NIO.2: how it differs from synchronous IO, how to work with AsynchronousFileChannel, launch read/write operations via Future and CompletionHandler, and how the choice of the ExecutorService thread pool affects behavior. In practice, we'll look at opening a channel via open, the read/write methods, the interaction flow, and common pitfalls.

How to handle completion of NIO2 asynchronous operations in Java: “promises” via Future and callbacks via CompletionHandler. We’ll examine the read/ write signatures on AsynchronousFileChannel, blocking result retrieval via get() and polling isDone(), as well as non-blocking handling in completed()/ failed(). We’ll show practical read/write examples and a brief comparison of the approaches.

Practising asynchronous I/O in Java: read large text files in blocks into ByteBuffer via AsynchronousFileChannel, correctly convert bytes to characters using CharsetDecoder, write data back asynchronously (via Future or CompletionHandler). We unpack the problem of “split” multibyte characters (for example, "UTF-8"), on-the-fly line counting, charset choice, and common mistakes when working with buffers and channels.

How to properly catch and handle errors in Java asynchronous I/O: CompletionHandler callbacks with completed/ failed methods, logging, and notifications. We cover canceling operations via Future and cancel( boolean), implications for get() and CancellationException, plus practical tips: try-with-resources, synchronization with CountDownLatch/ CompletableFuture, and resource cleanup.

A practical walkthrough of the pitfalls when working with asynchronous file I/O in Java NIO: correct buffer management for ByteBuffer (properties position/ limit, calls to flip(), clear(), compact()), races in parallel operations with AsynchronousFileChannel, closing resources ( channel.close(), try-with-resources), error handling in CompletionHandler (method failed(...)), managing operation lifecycle via Future<Integer> and synchronizing with CountDownLatch, correct handling of character encodings via CharsetDecoder, and choosing an appropriate thread pool with ExecutorService.

We’ll examine how platform threads differ from virtual ones: how the “ Platform Thread → OS” model works and why it’s heavy, what changes with virtual threads ( Virtual Thread) on top of carrier threads, and how this delivers scalability without reactive “spaghetti.” We’ll look at practical usage with Thread.ofVirtual(), compare behaviour for I/O‑bound and CPU‑bound tasks, touch on compatibility (blocking calls like InputStream.read, Socket.accept) and common mistakes (legacy synchronisation, expecting “magical speedups”).

Hands-on with Java 21 virtual threads: how they differ from platform threads, how to start them via Thread.startVirtualThread(...) and Thread.ofVirtual().start(...), when new Thread(...) or Thread.ofPlatform() is still appropriate, and how to execute tasks at scale using Executors.newVirtualThreadPerTaskExecutor(). We’ll cover waiting for completion via join(), error handling with Future and ExecutionException, and common pitfalls when using virtual threads.

A practical comparison of platform threads Thread and virtual threads in Java 21: how the JVM, thanks to “ carriers” (carrier threads), executes hundreds of thousands of tasks with minimal memory; where virtual threads shine (I/O-bound) and where they don’t (CPU-bound). We’ll examine limitations ( synchronized, native locks), best practices ( Executors.newVirtualThreadPerTaskExecutor()), monitoring via JVisualVM and Java Flight Recorder, as well as common mistakes when migrating to Virtual Threads.

We will break down how to run one task in a single virtual thread using Executors.newVirtualThreadPerTaskExecutor() (Java 21), how this differs from classic pools ( newFixedThreadPool, newCachedThreadPool), how to shut down properly via shutdown() and awaitTermination(...), how to get task results via Future, and where virtual threads deliver the biggest wins (mass I/O, web servers, load testing). At the end — common mistakes and gotchas.