Java Concurrency in Practice

ISBN: 0321349601
EAN: 2147483647

Year: 2004
Pages: 141

Authors: Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, Doug Lea

BUY ON AMAZON

Introduction

• Introduction
• A (Very) Brief History of Concurrency
• Benefits of Threads
• Risks of Threads
• Threads are Everywhere

Part I: Fundamentals

Thread Safety

• Thread Safety
• What is Thread Safety?
• Atomicity
• Locking
• Guarding State with Locks
• Liveness and Performance

Sharing Objects

• Sharing Objects
• Visibility
• Publication and Escape
• Thread Confinement
• Immutability
• Safe Publication

Composing Objects

• Composing Objects
• Designing a Thread-safe Class
• Instance Confinement
• Delegating Thread Safety
• Adding Functionality to Existing Thread-safe Classes
• Documenting Synchronization Policies

Building Blocks

• Building Blocks
• Synchronized Collections
• Concurrent Collections
• Blocking Queues and the Producer-consumer Pattern
• Blocking and Interruptible Methods
• Synchronizers
• Building an Efficient, Scalable Result Cache
• Summary of Part I

Part II: Structuring Concurrent Applications

• Part II: Structuring Concurrent Applications

Task Execution

• Task Execution
• Executing Tasks in Threads
• The Executor Framework
• Finding Exploitable Parallelism
• Summary

Cancellation and Shutdown

• Cancellation and Shutdown
• Task Cancellation
• Stopping a Thread-based Service
• Handling Abnormal Thread Termination
• JVM Shutdown
• Summary

Applying Thread Pools

• Applying Thread Pools
• Implicit Couplings Between Tasks and Execution Policies
• Sizing Thread Pools
• Configuring ThreadPoolExecutor
• Extending ThreadPoolExecutor
• Parallelizing Recursive Algorithms
• Summary

GUI Applications

• GUI Applications
• Why are GUIs Single-threaded?
• Short-running GUI Tasks
• Long-running GUI Tasks
• Shared Data Models
• Other Forms of Single-threaded Subsystems
• Summary

Part III: Liveness, Performance, and Testing

Avoiding Liveness Hazards

• Avoiding Liveness Hazards
• Deadlock
• Avoiding and Diagnosing Deadlocks
• Other Liveness Hazards
• Summary

Performance and Scalability

• Performance and Scalability
• Thinking about Performance
• Amdahls Law
• Costs Introduced by Threads
• Reducing Lock Contention
• Example: Comparing Map Performance
• Reducing Context Switch Overhead
• Summary

Testing Concurrent Programs

• Testing Concurrent Programs
• Testing for Correctness
• Testing for Performance
• Avoiding Performance Testing Pitfalls
• Complementary Testing Approaches
• Summary

Part IV: Advanced Topics

Explicit Locks

• Explicit Locks
• Lock and ReentrantLock
• Performance Considerations
• Fairness
• Choosing Between Synchronized and ReentrantLock
• Read-write Locks
• Summary

Building Custom Synchronizers

• Building Custom Synchronizers
• Managing State Dependence
• Using Condition Queues
• Explicit Condition Objects
• Anatomy of a Synchronizer
• AbstractQueuedSynchronizer
• AQS in Java.util.concurrent Synchronizer Classes
• Summary

Atomic Variables and Nonblocking Synchronization

• Atomic Variables and Nonblocking Synchronization
• Disadvantages of Locking
• Hardware Support for Concurrency
• Atomic Variable Classes
• Nonblocking Algorithms
• Summary

The Java Memory Model

• The Java Memory Model
• What is a Memory Model, and Why would I Want One?
• Publication
• Initialization Safety
• Summary
• Appendix A. Annotations for Concurrency
• Section A.1. Class Annotations
• Section A.2. Field and Method Annotations