Java多线程编程核心技术（第2版） (Java核心技术系列) (高洪岩 [高洪岩])（Z-Library）

【One-Line Pitch】 A hands-on, code-driven guide to Java multithreading, covering Thread APIs, synchronization, and concurrency control for developers who want to master core threading skills through practical examples and experiments. 【Book Arc】 - **Opening (~0%–10%)**: Introduces Java multithreading fundamentals—creating threads via extending Thread or implementing Runnable, starting threads with start(), and understanding execution randomness. It also highlights non-thread-safe issues, like the Servlet example, and introduces synchronized as a fix. - **Early (~10%–23%)**: Explores Thread core methods—sleep(), dumpStack(), interrupt(), suspend(), and resume()—with emphasis on their pitfalls, such as interrupt() only setting a flag and suspend() causing incomplete data. It also covers thread priority, showing that higher-priority threads often finish first but not always. - **Early (~23%–32%)**: Delves into instance variable non-thread-safety and the synchronized keyword, demonstrating how it locks objects, not methods, and how non-synchronized methods remain accessible. It also shows that exceptions automatically release locks. - **Middle (~39%–48%)**: Focuses on synchronized blocks, comparing them to synchronized methods for performance, and explains synchronized(this) and synchronized(non-this object) for finer-grained control. It emphasizes that using the same lock ensures synchronization, while different locks allow async execution. - **Middle (~48%–52%)**: Continues with advanced synchronization patterns, showing how to use arbitrary objects as locks and the effects of lock scope on thread behavior, preparing readers for more complex concurrency scenarios. 【Key Takeaways】 - **Thread creation basics** (Early): Extending Thread or implementing Runnable are the two primary ways to create threads; Runnable is preferred for multiple inheritance. Starting with start() is asynchronous, so execution order is unpredictable. (Early) - **interrupt() is a flag, not a stop** (Early): Calling interrupt() only marks a thread for interruption; it doesn't halt execution immediately. You need to check the flag in your code to stop gracefully. (Early) - **suspend() and resume() are deprecated** (Early): These methods can cause incomplete data or deadlocks, so avoid them. Use wait() and notify() instead for pausing and resuming threads. (Early) - **Priority affects but doesn't guarantee order** (Early): Higher-priority threads often finish first, but this isn't guaranteed. Priority influences scheduling, but the OS decides, so don't rely on it for correctness. (Early) - **synchronized locks objects, not methods** (Early): Adding synchronized to a method locks the current object, so other synchronized methods on the same object are blocked, but non-synchronized methods remain accessible. (Early) - **Exceptions release locks automatically** (Early): If a thread throws an exception inside a synchronized block, the lock is released, allowing other threads to proceed. This prevents deadlocks but requires careful error handling. (Early) - **synchronized blocks offer finer control** (Middle): Using synchronized(this) or synchronized(non-this object) lets you limit locking to specific code sections, improving performance compared to locking entire methods. (Middle) - **Same lock means synchronization** (Middle): For threads to synchronize, they must use the same lock object. Different locks allow async execution, which is useful for parallel tasks but risky for shared data. (Middle) 【Reading Tips】 - **Skim the code examples**: The book is heavily example-driven; focus on the code snippets and their outputs to understand concepts quickly. Recreate them in your IDE to see the behavior firsthand. - **Deep-read the synchronization chapters**: Chapters on synchronized methods and blocks are core; pay close attention to the lock object concept and how it affects thread behavior. This is where most beginners get confused. - **Watch for deprecated methods**: Sections on suspend(), resume(), and interrupt() are important for understanding pitfalls, but don't spend too much time memorizing them—focus on modern alternatives like wait() and notify(). - **Take notes on non-thread-safe scenarios**: The examples of instance variable issues and Servlet problems are practical; note the patterns to avoid in real-world coding. - **Skip the intro and focus on experiments**: The opening chapters are basic; if you're familiar with Thread, jump to the synchronization sections for advanced insights. 【Coverage Limits】 This guide covers the first half of the book, focusing on Thread APIs and synchronized basics. Later chapters on advanced concurrency tools (e.g., locks, concurrent collections) are not covered in the excerpts.