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

Interlocked internals

To understand how interlocked internals work under the hood, we're going to see what machine code is being generated when compiling the Interlocked.Increment method. If we just run the program in debug mode and look at the disassembly window, we will see the usual method call.

To see what is really going on, we have to enable all optimizations:

First, we need to build the code in the Release mode in Visual Studio.
Then, we have to go to Tools | Options | Debugging | General and uncheck the Suppress JIT optimization on module load option.
Finally, add a System.Diagnostics.Debugger.Break() method call to pause the code in debugger.

If everything is set, you will see the following code in the disassembly window:

Interlocked.Increment(ref counter);

00007FFEF22B49AE  lea         rcx,[rsi+20h]
00007FFEF22B49B2  lock add    dword ptr [rcx],1

Note

Please notice the lock prefix in the last line of the code. This prefix is an instruction to the CPU to perform an atomic increment...

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