Java Concurrency in Practice - page 1
- 1
- 2
- Java Concurrency in Practice
- Java Concurrency in Practice
- Table of Contents
- Copyright
- Advance Praise for Java Concurrency in Practice
- Listings
- Preface
- Chapter 1. Introduction
- Section 1.1. A (Very) Brief History of Concurrency
- Section 1.2. Benefits of Threads
- Section 1.3. Risks of Threads
- Section 1.4. Threads are Everywhere
- Part I: Fundamentals
- Chapter 2. Thread Safety
- Section 2.1. What is Thread Safety?
- Section 2.2. Atomicity
- Section 2.3. Locking
- Section 2.4. Guarding State with Locks
- Section 2.5. Liveness and Performance
- Chapter 3. Sharing Objects
- Section 3.1. Visibility
- Section 3.2. Publication and Escape
- Section 3.3. Thread Confinement
- Section 3.4. Immutability
- Section 3.5. Safe Publication
- Chapter 4. Composing Objects
- Section 4.1. Designing a Thread-safe Class
- Section 4.2. Instance Confinement
- Section 4.3. Delegating Thread Safety
- Section 4.4. Adding Functionality to Existing Thread-safe Classes
- Section 4.5. Documenting Synchronization Policies
- Chapter 5. Building Blocks
- Section 5.1. Synchronized Collections
- Section 5.2. Concurrent Collections
- Section 5.3. Blocking Queues and the Producer-consumer Pattern
- Section 5.4. Blocking and Interruptible Methods
- Section 5.5. Synchronizers
- Section 5.6. Building an Efficient, Scalable Result Cache
- Summary of Part I
- Part II: Structuring Concurrent Applications
- Chapter 6. Task Execution
- Section 6.1. Executing Tasks in Threads
- Section 6.2. The Executor Framework
- Section 6.3. Finding Exploitable Parallelism
- Summary
- Chapter 7. Cancellation and Shutdown
- Section 7.1. Task Cancellation
- Section 7.2. Stopping a Thread-based Service
- Section 7.3. Handling Abnormal Thread Termination
- Section 7.4. JVM Shutdown
- Summary
- Chapter 8. Applying Thread Pools
- Section 8.1. Implicit Couplings Between Tasks and Execution Policies
- Section 8.2. Sizing Thread Pools
- Section 8.3. Configuring ThreadPoolExecutor
- Section 8.4. Extending ThreadPoolExecutor
- Section 8.5. Parallelizing Recursive Algorithms
- Summary
- Chapter 9. GUI Applications
- Section 9.1. Why are GUIs Single-threaded?
- Section 9.2. Short-running GUI Tasks
- Section 9.3. Long-running GUI Tasks
- Section 9.4. Shared Data Models
- Section 9.5. Other Forms of Single-threaded Subsystems
- Summary
- Part III: Liveness, Performance, and Testing
- Chapter 10. Avoiding Liveness Hazards
- Section 10.1. Deadlock
- Section 10.2. Avoiding and Diagnosing Deadlocks
- Section 10.3. Other Liveness Hazards
- Summary
- Chapter 11. Performance and Scalability
- Section 11.1. Thinking about Performance
- Section 11.2. Amdahl s Law
- Section 11.3. Costs Introduced by Threads
- Section 11.4. Reducing Lock Contention
- Section 11.5. Example: Comparing Map Performance
- Section 11.6. Reducing Context Switch Overhead
- Summary
- Chapter 12. Testing Concurrent Programs
- 1
- 2
