Pro .NET 4 Parallel Programming in C#

Prelim
Contents at a Glance
Contents
About the Author
About the Technical Reviewer
Acknowledgments
Introducing Parallel Programming
Introducing .NET Parallel Programming
What’s in This Book (and What Is Not)
Understanding the Benefits (and Pitfalls) of Parallel Programming
Considering Overhead
Coordinating Data
Scaling Applications
Deciding When to Go Parallel
Deciding When to Stay Sequential
Getting Prepared for This Book
Understanding the Structure of This Book
Getting the Example Code
Summary
Task Programming
Hello Task
Creating and Starting Tasks
Creating Simple Tasks
Setting Task State
Getting a Result
Specifying Task Creation Options
Identifying Tasks
Cancelling Tasks
Monitoring Cancellation by Polling
Monitoring Cancellation with a Delegate
Monitoring Cancellation with a Wait Handle
Cancelling Several Tasks
Creating a Composite Cancellation Token
Determining If a Task Was Cancelled
Waiting for Time to Pass
Using a Cancellation Token Wait Handle
Using Classic Sleep
Using Spin Waiting
Waiting for Tasks
Waiting for a Single Task
Waiting for Several Tasks
Waiting for One of Many Tasks
Handling Exceptions in Tasks
Handling Basic Exceptions
Using an Iterative Handler
Reading the Task Properties
Using a Custom Escalation Policy
Getting the Status of a Task
Executing Tasks Lazily
Understanding Common Problems and Their Causes
Task Dependency Deadlock
Solution
Example
Local Variable Evaluation
Solution
Example
Excessive Spinning
Solution
Example
Summary
Sharing Data
The Trouble with Data
Going to the Races
Creating Some Order
Executing Sequentially
Executing Immutably
Executing in Isolation
Synchronizing Execution
Defining Critical Regions
Defining Synchronization Primitives
Using Synchronization Wisely
Don’t Synchronize Too Much
Don’t Synchronize Too Little
Pick the Lightest Tool
Don’t Write Your Own Synchronization Primitives
Using Basic Synchronization Primitives
Locking and Monitoring
Using Interlocked Operations
Using Spin Locking
Using Wait Handles and the Mutex Class
Acquiring Multiple Locks
Configuring Interprocess Synchronization
Using Declarative Synchronization
Using Reader-Writer Locks
Using the ReaderWriterLockSlim Class
Using Recursion and Upgradable Read Locks
Working with Concurrent Collections
Using .NET 4 Concurrent Collection Classes
ConcurrentQueue
ConcurrentStack
ConcurrentBag
ConcurrentDictionary
Using First-Generation Collections
Using Generic Collections
Common Problems and Their Causes
Unexpected Mutability
Solution
Example
Multiple Locks
Solution
Example
Lock Acquisition Order
Solution
Example
Orphaned Locks
Solution
Example
Summary
Coordinating Tasks
Doing More with Tasks
Using Task Continuations
Creating Simple Continuations
Creating One-to-Many Continuations
Creating Selective Continuations
Creating Many-to-One and Any-To-One Continuations
Canceling Continuations
Waiting for Continuations
Handling Exceptions
Creating Child Tasks
Using Synchronization to Coordinate Tasks
Barrier
CountDownEvent
ManualResetEventSlim
AutoResetEvent
SemaphoreSlim
Using the Parallel Producer/Consumer Pattern
Creating the Pattern
Creating a BlockingCollection instance
Selecting the Collection Type
Creating the Producers
Creating the Consumer
Combining Multiple Collections
Using a Custom Task Scheduler
Creating a Custom Scheduler
Using a Custom Scheduler
Common Problems and Their Causes
Inconsistent/Unchecked Cancellation
Solution
Example
Assuming Status on Any-To-One Continuations
Solution
Example
Trying to Take Concurrently
Solution
Example
Reusing Objects in Producers
Solution
Example
Using BlockingCollection as IEnumerable
Solution
Example
Deadlocked Task Scheduler
Solution
Example
Summary
Parallel Loops
Parallel vs. Sequential Loops
The Parallel Class
Invoking Actions
Using Parallel Loops
Creating a Basic Parallel For Loop
Creating a Basic Parallel ForEach Loop
Setting Parallel Loop Options
Breaking and Stopping Parallel Loops
Handling Parallel Loop Exceptions
Getting Loop Results
Canceling Parallel Loops
Using Thread Local Storage in Parallel Loops
Performing Parallel Loops with Dependencies
Selecting a Partitioning Strategy
Using the Chunking Partitioning Strategy
Using the Ordered Default Partitioning Strategy
Creating a Custom Partitioning Strategy
Writing a Contextual Partitioner
Writing an Orderable Contextual Partitioner
Common Problems and Their Causes
Synchronization in Loop Bodies
Solution
Example
Loop Body Data Races
Solution
Example
Using Standard Collections
Solution
Example
Using Changing Data
Solution
Example
Summary
Parallel LINQ
LINQ, But Parallel
Using PLINQ Queries
Using PLINQ Query Features
Ordering Query Results
Using Ordered Subqueries
Performing a No-Result Query
Managing Deferred Query Execution
Controlling Concurrency
Forcing Parallelism
Limiting Parallelism
Forcing Sequential Execution
Handling PLINQ Exceptions
Cancelling PLINQ Queries
Setting Merge Options
Using Custom Partitioning
Using Custom Aggregation
Generating Parallel Ranges
Common Problems and Their Causes
Forgetting the PLINQ Basics
Solution
Creating Race Conditions
Solution
Example
Confusing Ordering
Solution
Example
Sequential Filtering
Solution
Example
Summary
Testing and Debugging
Making Things Better When Everything Goes Wrong
Measuring Parallel Performance
Using Good Coding Strategies
Using Synchronization Sparingly
Using Synchronization Readily
Partitioning Work Evenly
Avoiding Parallelizing Small Work Loads
Measure Different Degrees of Concurrency
Making Simple Performance Comparisons
Performing Parallel Analysis with Visual Studio
Finding Parallel Bugs
Debugging Program State
Handling Exceptions
Detecting Deadlocks
Summary
Common Parallel Algorithms
Sorting, Searching, and Caching
Using Parallel Quicksort
The Code
Using the Code
Traversing a Parallel Tree
The Code
Using the Code
Searching a Parallel Tree
The Code
Using the Code
Using a Parallel Cache
The Code
Using the Code
Using Parallel Map and Reductions
Using a Parallel Map
The Code
Using the Code
Using a Parallel Reduction
The Code
Using the Code
Using Parallel MapReduce
The Code
Using the Code
Speculative Processing
Selection
The Code
Using the Code
Speculative Caching
The Code
Using the Code
Using Producers and Consumers
Decoupling the Console Class
The Code
Using the Code
Creating a Pipeline
The Code
Using the Code
Index
¦A
¦B
¦C
D
¦
¦E
¦F
¦G
¦H
¦I
¦J
¦M
¦K
¦L
P
¦
¦N
¦O
R
¦
¦Q
¦S
T
¦
¦U
¦V
¦W