Java异步编程实战 (Java核心技术系列) (翟陆续)（Z-Library）

【One-Line Pitch】 A practical, code-driven tour of how Java actually does asynchronous work—from raw threads to reactive streams—so you can pick the right tool instead of guessing. Best for intermediate Java developers who already write concurrent code and want a unified map of the async landscape. 【Book Arc】 - **Opening (~0%–12%)**: Frames why async matters (parallelism, responsiveness) and starts with the simplest tools—explicit `Thread`, thread pools, rejection policies, and the executor internals you must understand before anything else. - **Early (~12%–31%)**: Moves into result-bearing tasks: `FutureTask` state machine, cancellation, `CompletableFuture` composition (`thenCompose`, `thenCombine`, `allOf`), and the first taste of declarative/functional style via Streams. - **Middle (~31%–46%)**: Applies async inside Spring—`TaskExecutor`, `@Async`, CGLIB proxying, and the `AsyncAnnotationAdvisor`/interceptor machinery that makes annotation-based async work. - **Late (~46%–54%)**: Diagnoses the limits of callbacks and Futures (Callback Hell, weak composition), then introduces reactive programming with RxJava and Reactor as the answer. - **Ending (~54% onward)**: Shifts to the web tier—Servlet 3.0 async processing and Servlet 3.1 non-blocking IO—showing how async reaches the request-handling layer. 【Key Takeaways】 - **Async is a spectrum, not one technique** (Opening): the book deliberately unifies scattered Java async APIs—single-JVM, RPC, and web—so you can see relationships rather than isolated docs. - **Thread pools are the substrate** (Opening): explicit `Thread` is the simplest path, but pooling, core/max sizing, queues, and rejection policies (Abort, CallerRuns, Discard, DiscardOldest) are the real levers. - **`FutureTask` is a cancellable state machine** (Early): its `NEW→COMPLETING→NORMAL/EXCEPTIONAL/CANCELLED/INTERRUPTED` transitions and CAS-based completion explain why `get()` blocks and how cancellation really behaves. - **`CompletableFuture` enables composition** (Early): `thenCompose`, `thenCombine`, and `allOf` let you chain and fan-in async results—the practical cure for nested callbacks. - **Spring's `@Async` is proxy magic** (Middle): understanding the CGLIB proxy, `AsyncAnnotationAdvisor`, and executor selection prevents the classic "why isn't my method async?" trap. - **Callbacks and Futures have hard limits** (Late): poor composability, no lazy evaluation, and weak error handling push you toward reactive libraries. - **Reactive programming trades familiarity for composability** (Late): RxJava/Reactor add operators, backpressure, and "nothing happens until subscribe," at the cost of a new mental model. - **Async reaches the servlet layer** (Ending): Servlet 3.0 async and 3.1 non-blocking IO let container threads be freed during slow request handling. 【Reading Tips】 - Deep-read the executor and `FutureTask` chapters—they underpin everything later; skim the repeated code listings once you grasp the pattern. - Treat the Spring `@Async` chapter as a debugging reference: the proxy/interceptor internals are where real production bugs hide. - If you only need one modern tool, prioritize `CompletableFuture` and Reactor sections; the RxJava material is broader but overlaps. - Keep the book's stated goal in mind—it's a unified reference, not a linear tutorial—so jump between chapters by scenario (single-JVM, RPC, web). 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book; later chapters on RPC async and advanced reactive/WebFlux internals are only partially represented, so specifics there are not fully summarized.