Initialization Safety
Summary
The Java Memory Model specifies when the actions of one thread on memory are guaranteed to be visible to another. The specifics involve ensuring that operations are ordered by a partial ordering called happens-before, which is specified at the level of individual memory and synchronization operations. In the absence of sufficient synchronization, some very strange things can happen when threads access shared data. However, the higher-level rules offered in Chapters 2 and 3, such as @GuardedBy and safe publication, can be used to ensure thread safety without resorting to the low-level details of happens-before.
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
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
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
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
EAN: 2147483647
Pages: 141
