The article explains multiple methods for implementing asynchronous execution in Spring Boot, covering @Async annotation, Java 8 CompletableFuture, Callable, WebAsyncTask, DeferredResult, Tomcat connection tuning, container switching to Undertow, and async interception, all illustrated with complete code examples.
The article explains that CompletableFuture offers paired asynchronous methods—one using the default ForkJoinPool and another accepting a custom executor—and argues that providing an explicit thread pool avoids shared‑pool contention, loss of tracing information, ThreadLocal leakage, and class‑loader issues in Java backend applications.
This article explains multiple ways to achieve asynchronous processing in Spring Boot, covering @Async annotation, CompletableFuture, WebAsyncTask, DeferredResult, Tomcat connection tuning, component scanning, Undertow migration, BufferedWriter usage, and AsyncHandlerInterceptor with detailed code examples.
This article explains how Java 8's CompletableFuture enables low‑overhead asynchronous composition, walks through its core methods, shows practical code examples for parallel data fetching, error handling, and task combination, and reveals implementation details from the source code.
The article explains how Java 8’s CompletableFuture enables efficient asynchronous programming—illustrated by Meituan’s order service refactor—by replacing slow synchronous RPC calls with composable, lazy, back‑pressure‑aware futures, offering thread‑pool best practices, robust exception handling, utility helpers, and achieving up to a 45 % latency reduction and fewer servers.
This article explores multiple ways to implement asynchronous processing in Spring Boot, covering @Async with @EnableAsync, CompletableFuture, DeferredResult, WebAsyncTask, AsyncHandlerInterceptor, as well as related server tweaks like increasing Tomcat connections, switching to Undertow, and using @ComponentScan for faster scanning.
This article explains multiple ways to implement asynchronous processing in Spring Boot, covering @Async annotation, CompletableFuture, supplyAsync, runAsync, WebAsyncTask, DeferredResult, custom interceptors, and server configuration tweaks such as Tomcat connection limits and switching to Undertow.
This article explains Java's CompletableFuture—its purpose, key features like thenCompose, thenCombine, thenAccept, thenRun, thenApply, and provides a detailed walkthrough of its internal implementation, including code examples and the mechanics of task dependency handling.
This article explains how to implement asynchronous processing in Spring Boot using @Async annotations, JDK 8 CompletableFuture, Callable, WebAsyncTask, DeferredResult, and AsyncHandlerInterceptor, providing detailed code examples and configuration tips to improve performance and scalability of backend services.
The article explains why CompletableFuture was introduced in JDK 1.8, describes its core features such as thenCompose, thenCombine, thenAccept, thenRun and thenApply, demonstrates usage with Netty's ChannelFuture and detailed source‑code walkthroughs including asyncSupplyStage, AsyncSupply, uniAcceptStage and postComplete, and provides practical code examples and execution results.
This article provides an in‑depth analysis of Java’s CompletableFuture introduced in JDK 8, explaining its motivations, core methods, internal mechanisms such as asyncSupplyStage, thenAcceptAsync, and postComplete, and includes practical code examples to illustrate asynchronous task handling and dependency management.
This article explains Java 8's CompletableFuture, covering its purpose, core features such as thenCompose, thenCombine, thenAccept, thenRun, and thenApply, demonstrates practical code examples, and provides a detailed analysis of the underlying source‑code implementation for asynchronous callbacks.
This article explains how to replace synchronous price‑lookup APIs with Java 8's CompletableFuture, compares synchronous and asynchronous performance, introduces the most useful CompletableFuture creation and composition methods, shows practical code examples, and discusses when to prefer it over traditional Future or thread‑pool approaches.
This article introduces Java's CompletableFuture, compares it with the older Future API, demonstrates how to create, combine, and handle asynchronous tasks with code examples, and highlights best practices and pitfalls for effective concurrent programming.
To reduce response time when invoking multiple independent APIs, this article demonstrates how to refactor sequential Java calls into asynchronous executions using thread pools and CompletableFuture, providing complete code examples and performance comparisons.
This article explains the difference between synchronous and asynchronous method calls in Spring Boot, demonstrates how to convert simple task methods to asynchronous ones using @Async, shows how to coordinate multiple async tasks with CompletableFuture, and provides complete code examples and test results.
This article explains Java 8's CompletionStage API and its standard library implementation CompletableFuture, demonstrating its behavior through a series of concise examples that cover creation, chaining, asynchronous execution, custom executors, exception handling, cancellation, and composition of multiple stages.
This article compares synchronous and various asynchronous approaches for invoking multiple third‑party services in a Spring Boot order‑creation workflow, demonstrating plain sequential calls, manual thread creation, thread‑pool execution, CompletionService handling, and CompletableFuture composition, and shows their performance impact through timing results.
The article explains Java’s concurrency utilities—thread pools, Future, CompletableFuture, and CompletionService—and introduces the divide‑and‑conquer Fork/Join framework, detailing its task model, core classes, work‑stealing mechanism, and best practices for CPU‑bound versus I/O‑bound parallel streams.
This article introduces Java's CompletableFuture and CompletionStage APIs, explains their contracts, and provides twenty concise code examples that demonstrate creating completed futures, running async stages, applying functions synchronously and asynchronously, handling exceptions, combining futures, using custom executors, and orchestrating multiple stages with allOf/anyOf.
This article walks through the evolution of Java asynchronous programming, starting with a simple synchronous HTTP call, examining blocking I/O, exploring JDK NIO and Future, demonstrating callback patterns, addressing callback hell, and showing how CompletableFuture, Vert.x Future, Reactive Streams, and Spring WebFlux provide scalable, non‑blocking solutions.
This article explains asynchronous and non‑blocking concepts, why traditional synchronous code hurts performance, and walks through Java's evolution from raw Thread usage to Future and the powerful CompletableFuture API, including practical examples, pros, cons, and web‑framework support.
This article explains how to enforce a specific execution order among three Java threads—first thread 1, then thread 2, and finally thread 3—using four techniques: the join method, CountDownLatch, a single‑thread executor, and CompletableFuture, each illustrated with complete code examples.
The article analyzes a production incident where a Dubbo thread pool exhausted its threads due to CompletableFuture#join blocking, explains how the custom business thread pool caused mutual waiting, and presents a solution that isolates asynchronous tasks into a separate pool to restore service stability.
This article introduces Java 8's CompletionStage API and its CompletableFuture implementation, explains the contract of CompletionStage, and demonstrates a wide range of synchronous and asynchronous operations—including creation, chaining, exception handling, combinators, and real‑world usage—through concise code examples.
This article explains how Java's CompletableFuture and CompletionStage APIs enable asynchronous programming without external libraries, providing detailed explanations and 20 code examples that cover creation, chaining, combining, exception handling, cancellation, and execution with custom executors.
An extensive guide to Java 8’s new capabilities, covering lambda expressions, functional interfaces, streams, default methods, Optional, CompletableFuture, the new date‑time API, concurrency enhancements, and numerous language and library improvements, with detailed explanations and code examples.
This article explains how to use JDK’s Future and FutureTask for asynchronous computation, walks through their APIs, internal state machine, core methods like run(), get(), cancel(), and highlights their limitations while introducing CompletableFuture as a more powerful alternative.
This article explains the code types involved in synchronous remote calls, demonstrates how blocking IO leads to callback hell, and shows how to simplify the programming model using Java CompletableFuture, AsyncHttpClient, and Project Reactor’s reactive streams to efficiently retrieve city data.
This article explores the evolution of parallel computing in Java, explaining why single‑core performance stalls, how multi‑core CPUs and GPUs enable true concurrency, and demonstrating practical implementations using CountDownLatch, CompletableFuture, Fork/Join, parallel streams, and sharding, while highlighting performance considerations and pitfalls.
This article introduces asynchronous programming concepts, focusing on Promise-style APIs, their differences from synchronous and callback approaches, and practical usage patterns in backend development.
