Java高并发编程详解：多线程与架构设计 (汪文君)（Z-Library）

【One-Line Pitch】 A comprehensive, hands-on guide to Java multithreading and concurrency, covering everything from thread fundamentals and synchronization to JVM class loading and classic design patterns—ideal for intermediate Java developers who want to build robust, high-performance concurrent systems. 【Book Arc】 - **Opening (~0%–9%)**: Introduces threads from scratch—how to create and start them, the thread lifecycle, and why `start()` differs from `run()`. Uses template and strategy patterns to explain Thread's design, with a practical ticket-window simulation to illustrate basic concurrency issues. - **Early (~9%–25%)**: Dives into Thread constructors and API details—naming, parent-child relationships, daemon threads, `sleep`, `yield`, `join`, and interruption. Also covers safe thread shutdown techniques and introduces diagnostic tools like jvisualvm for spotting "zombie" processes. - **Early (~25%–34%)**: Tackles thread safety and data synchronization. Explains the `synchronized` keyword, monitor locks, and the difference between this-monitor and class-monitor. Includes deadlock causes and diagnosis using jstack/jconsole, plus a warning about HashMap's thread-unsafe behavior under concurrency. - **Middle (~34%–47%)**: Explores inter-thread communication via `wait`/`notify`/`notifyAll`, the producer-consumer model, and the "wait set" concept. Also covers building a custom explicit `BooleanLock` with interruptible and timeout capabilities, followed by a detailed look at ThreadGroup creation and operations. - **Middle (~47%–53%)**: Continues ThreadGroup operations—interrupting all threads in a group, priority inheritance rules, and practical API usage. The excerpts show how group-level interrupts and max-priority settings affect member threads. - **Late (~53%–end)**: Moves into advanced topics: JVM class loading and custom class loaders, the volatile keyword and Java Memory Model, and a catalog of design patterns (Observer, Single Thread Execution, Read-Write Lock, Immutable Object, Future, Guarded Suspension, Thread Context, Balking, Latch). These patterns provide reusable architectures for real-world concurrent programming. 【Key Takeaways】 - **Thread lifecycle is strict** (Early): A thread can only be started once; calling `start()` again throws `IllegalThreadStateException`, whether the thread is still running or already terminated. Understanding this prevents common misuse. - **Thread creation follows a template pattern** (Early): `Thread.start()` is the fixed algorithm, while `run()` is the overridable hook. This design lets you control execution flow while delegating task logic to subclasses or `Runnable` implementations. - **`sleep` never releases monitors** (Early): Unlike `wait`, `sleep` pauses the current thread without giving up lock ownership. Use `TimeUnit` instead of raw `Thread.sleep` for clearer, more maintainable time expressions. - **Safe thread shutdown requires cooperation** (Early): Avoid the deprecated `stop()` method; instead, use interrupt signals or a volatile flag to let threads exit gracefully. This prevents resource leaks and inconsistent states. - **`synchronized` ensures mutual exclusion and memory visibility** (Early): It compiles to `monitor enter`/`exit` instructions, forcing threads to read from and write to main memory, and obeying happens-before rules. Use it on methods or blocks, never on classes or variables directly. - **Deadlocks come in two flavors** (Early): Cross-lock deadlocks leave threads BLOCKED and are easy to detect with jstack; infinite-loop "fake deadlocks" (e.g., unsynchronized HashMap) burn CPU and are harder to diagnose. Prefer `ConcurrentHashMap` for thread-safe maps. - **`wait`/`notify` require careful condition handling** (Middle): Always use `while` loops instead of `if` for condition checks, and prefer `notifyAll` over `notify` to avoid missed signals in multi-threaded producer-consumer scenarios. The wait set is implementation-defined, so don't rely on wake-up order. - **ThreadGroup is for organization, not management** (Middle): It provides batch operations like `interrupt()` and `list()`, but doesn't control thread execution. Priority settings on a group only affect threads added after the change, not existing ones. 【Reading Tips】 - **Skim the first two chapters** if you're already comfortable with basic thread creation and lifecycle; focus instead on the constructor details (parent-child, daemon, stack size) and the API chapter for practical nuances like `TimeUnit` and safe shutdown. - **Deep-read Chapter 4 (synchronized) and Chapter 5 (communication)**—these are the core of thread safety. Work through the ticket-window and producer-consumer examples line by line, and run the deadlock demos with jstack to see diagnostics in action. - **Treat the design patterns section (Chapters 15–23) as a reference library**: You don't need to memorize every pattern, but understand the problem each solves (e.g., Read-Write Lock for read-heavy workloads, Future for async results) and revisit them when designing your own concurrent systems. - **Watch for the volatile and JMM chapters (12–14)**: These are conceptually dense but crucial for understanding visibility and ordering. The singleton pattern examples (7 variants) are a great way to test your grasp of volatile and double-checked locking. - **Skip the ClassLoader chapters (9–11) if your focus is pure concurrency**, but return to them if you're dealing with custom class loading or JDBC driver initialization—they explain why thread context class loaders exist. 【Coverage Limits】 This guide covers the first ~53% of the book in detail (thread fundamentals, synchronization, communication, ThreadGroup). The later sections on class loading, volatile, and design patterns are summarized from the table of contents; excerpts do not provide in-depth content for those chapters.