6. Using Concurrent Data Structures | Mastering C# Concurrency

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Mastering C# Concurrency

2.3 (3)

Mastering C# Concurrency

2.3 (3)

Overview of this book

Starting with the traditional approach to concurrency, you will learn how to write multithreaded concurrent programs and compose ways that won't require locking. You will explore the concepts of parallelism granularity, and fine-grained and coarse-grained parallel tasks by choosing a concurrent program structure and parallelizing the workload optimally. You will also learn how to use task parallel library, cancellations, timeouts, and how to handle errors. You will know how to choose the appropriate data structure for a specific parallel algorithm to achieve scalability and performance. Further, you'll learn about server scalability, asynchronous I/O, and thread pools, and write responsive traditional Windows and Windows Store applications. By the end of the book, you will be able to diagnose and resolve typical problems that could happen in multithreaded applications.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Traditional Concurrency

1. Traditional Concurrency

What's the problem?

Using locks

Reader-writer lock

Spin lock

Optimization strategy

Summary

2. Lock-Free Concurrency

2. Lock-Free Concurrency

Memory model and compiler optimizations

The System.Threading.Interlocked class

Interlocked internals

Writing lock-free code

Summary

3. Understanding Parallelism Granularity

3. Understanding Parallelism Granularity

The number of threads

Using the thread pool

Understanding granularity

Choosing the coarse-grained or fine-grained approach

Summary

4. Task Parallel Library in Depth

4. Task Parallel Library in Depth

Task composition

Tasks hierarchy

Awaiting task completion

Task cancellation

Latency and the coarse-grained approach with TPL

Exception handling

Using the Parallel class

Summary

5. C# Language Support for Asynchrony

5. C# Language Support for Asynchrony

Implementing the downloading of images from Bing

Is the async keyword really needed?

Fire-and-forget tasks

Other useful TPL features

Implementing a custom awaitable type

Summary

6. Using Concurrent Data Structures

6. Using Concurrent Data Structures

Standard collections and synchronization primitives

Implementing a cache with ReaderWriterLockSlim

Concurrent collections in .NET

ConcurrentDictionary

ConcurrentBag

ConcurrentQueue

ConcurrentStack

The Producer/Consumer pattern

The Producer/Consumer pattern in .NET 4.0+

Summary

7. Leveraging Parallel Patterns

7. Leveraging Parallel Patterns

Concurrent idioms

Asynchronous patterns

Concurrent patterns

Summary

8. Server-side Asynchrony

8. Server-side Asynchrony

Server applications

The OWIN Web API framework

Load testing and scalability

I/O and CPU-bound tasks

Deep dive into asynchronous I/O

Real and fake asynchronous I/O operations

Synchronization context

CPU-bound tasks and queues

Summary

9. Concurrency in the User Interface

9. Concurrency in the User Interface

The importance of asynchrony for UI

UI threads and message loops

Common problems and solutions

How the await keyword works

Performance issues

Summary

10. Troubleshooting Parallel Programs

10. Troubleshooting Parallel Programs

How troubleshooting parallel programs is different

Writing tests

Integration tests

Debugging

Performance measurement and profiling

Summary

Index

Index

ConcurrentDictionary

We can improve the implementation of CustomProvider using ConcurrentDictionary<TKey, TValue> to handle the synchronization:

public class CustomProvider
{
    private readonly 
        ConcurrentDictionary<string, OperationResult> _cache = 
            new ConcurrentDictionary<string, OperationResult>();
 
    public OperationResult RunOperationOrGetFromCache(
        string operationId)
    {
        return _cache.GetOrAdd(operationId, 
            id => RunLongRunningOperation(id));
    }
 
    private OperationResult RunLongRunningOperation(
        string operationId)
    {
        // Running real long-running operation
        // ...
        Console.WriteLine("Running long-running operation");
        return OperationResult.Create(operationId);
    }
}

The code became much simpler. We just used the GetOrAdd method and it does exactly what we need; if there is an element in the dictionary, it just returns its value or runs a provided delegate, gets...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Mastering C# Concurrency

Search

Your notes and bookmarks