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

Concurrent collections in .NET

Since the first .NET Framework version, most of the collections in the System.Collections namespace contained the Synchronized factory method that creates a thread safe wrapper over the collection instance, which ensures thread safety:

var source = Enumerable.Range(1, 42000).ToList();
var destination = ArrayList.Synchronized(new List<int>());
 
Parallel.ForEach(source,
    n =>
    {
        destination.Add(n);
    });
 
Assert.AreEqual(source.Count, destination.Count);

The synchronized collection wrapper can be used in a concurrent environment, but its efficiency is low, since it uses simple locking ensuring exclusive collection access for every operation. This approach is called coarse-grained locking and it is described in Chapter 3, Understanding Parallelism Granularity. It does not scale well with an increase in the number of clients and the amount of data inside the collection.

A complicated, but an efficient, approach is to use fine-grained locking...

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