掌握C#并发编程：实战指南

5星 · 超过95%的资源需积分: 10 68 浏览量更新于2024-07-22 2 收藏 9.35MB PDF 举报

"Concurrency.in.Csharp.Cookbook.2014.5.pdf 是一本由 Stephen Cleary 撰写的关于 C# 并发编程的实战指南。这本书详细探讨了 C# 中的并发、多线程、反应式编程模型以及并行处理等主题，旨在帮助开发者更好地理解和应对并发编程的挑战。书中的内容覆盖了现代 .NET 应用开发中的关键技术，并以易于理解的格式提供全面的参考。这本书得到了 Scott Hanselman、Jon Skeet 和 Stephen Toub 等业界知名专家的高度评价，他们一致认为它是 .NET 并发编程的理想参考资料。" 本书的核心知识点包括： 1. **并发基础**：书中会介绍并发编程的基本概念，包括进程、线程、任务和异步操作等，帮助读者建立对并发编程的基础理解。 2. **线程管理**：探讨如何在 C# 中创建和管理线程，包括线程同步、互斥锁、信号量和事件等机制，以确保线程安全地访问共享资源。 3. **任务并行库（TPL）**：介绍 .NET Framework 提供的任务并行库，包括 Task 类和 Parallel 类，以及如何使用它们来实现高效的并行操作。 4. **异步编程**：深入讲解基于 async/await 关键字的异步编程模型，如何编写非阻塞的异步方法，以及如何处理异步操作的错误。 5. **反应式编程**：介绍反应式扩展（Reactive Extensions，Rx）框架，展示如何利用 Observable 序列来处理事件流和响应式编程。 6. **并发设计模式**：讨论多种并发设计模式，如生产者消费者模型、工作窃取算法等，帮助解决实际开发中的并发问题。 7. **性能优化**：涵盖如何度量和优化并发代码的性能，以及避免常见的性能瓶颈。 8. **并发中的错误处理**：讲解在并发环境中如何正确处理异常，避免死锁、竞态条件等并发问题。 9. **并发工具和类库**：介绍 .NET Framework 中的其他并发相关工具和类库，如 ConcurrentDictionary、ConcurrentQueue 等线程安全数据结构。 10. **最佳实践与指导原则**：提供在 C# 中进行并发编程的最佳实践和指导原则，帮助开发者写出更高效、更可靠的并发代码。通过这本书，读者不仅可以学习到 C# 并发编程的具体技术，还能理解并发背后的原理，从而在实际项目中更加游刃有余地处理多线程和并行计算的问题。无论你是初学者还是经验丰富的开发者，这本书都能为你提供宝贵的指导。

Of course, this book would not be nearly as good as it is without my editor, Brian

MacDonald, and our technical reviewers: Stephen Toub, Petr Onderka (“svick”), and

Nick Paldino (“casperOne”). So if any mistakes get through, it’s totally their fault. Just

kidding! Their input has been invaluable in shaping (and fixing) the content, and any

remaining mistakes are of course my own.

Finally, I’d like to thank some of the people I’ve learned these techniques from: Stephen

Toub, Lucian Wischik, Thomas Levesque, Lee Campbell, the members of Stack Over‐

flow and the MSDN Forums, and the attendees of the software conferences in and

around my home state of Michigan. I appreciate being a part of the software develop‐

ment community, and if this book adds any value, it is only because of so many who

have already shown the way. Thank you all!

xii | Preface

application; higher-level abstractions are more powerful and more efficient than old-

school multithreading. As a consequence, I’ll minimize my coverage of outdated tech‐

niques in this book. None of the multithreading recipes in this book use the Thread or

BackgroundWorker types; they have been replaced with superior alternatives.

As soon as you type new Thread(), it’s over; your project already has

legacy code.

But don’t get the idea that multithreading is dead! Multithreading lives on in the thread

pool, a useful place to queue work that automatically adjusts itself according to de‐

mand. In turn, the thread pool enables another important form of concurrency: parallel

processing.

Parallel Processing

Doing lots of work by dividing it up among multiple threads that run concurrently.

Parallel processing (or parallel programming) uses multithreading to maximize the use

of multiple processors. Modern CPUs have multiple cores, and if there’s a lot of work

to do, then it makes no sense to just make one core do all the work while the others sit

idle. Parallel processing will split up the work among multiple threads, which can each

run independently on a different core.

Parallel processing is one type of multithreading, and multithreading is one type of

concurrency. There’s another type of concurrency that is important in modern appli‐

cations but is not (currently) familiar to many developers: asynchronous programming.

Asynchronous Programming

A form of concurrency that uses futures or callbacks to avoid unnecessary threads.

A future (or promise) is a type that represents some operation that will complete in the

future. The modern future types in .NET are Task and Task<TResult>. Older asyn‐

chronous APIs use callbacks or events instead of futures. Asynchronous programming

is centered around the idea of an asynchronous operation: some operation that is started

that will complete some time later. While the operation is in progress, it does not block

the original thread; the thread that starts the operation is free to do other work. When

the operation completes, it notifies its future or invokes its completion callback event

to let the application know the operation is finished.

Asynchronous programming is a powerful form of concurrency, but until recently, it

required extremely complex code. The async and await support in VS2012 make asyn‐

chronous programming almost as easy as synchronous (nonconcurrent) programming.

2 | Chapter 1: Concurrency: An Overview

Another form of concurrency is reactive programming. Asynchronous programming

implies that the application will start an operation that will complete once at a later time.

Reactive programming is closely related to asynchronous programming, but is built on

asynchronous events instead of asynchronous operations. Asynchronous events may not

have an actual “start,” may happen at any time, and may be raised multiple times. One

example is user input.

Reactive Programming

A declarative style of programming where the application reacts to events.

If you consider an application to be a massive state machine, the application’s behavior

can be described as reacting to a series of events by updating its state at each event. This

is not as abstract or theoretical as it sounds; modern frameworks make this approach

quite useful in real-world applications. Reactive programming is not necessarily con‐

current, but it is closely related to concurrency, so we’ll be covering the basics in this

book.

Usually, a mixture of techniques are used in a concurrent program. Most applications

at least use multithreading (via the thread pool) and asynchronous programming. Feel

free to mix and match all the various forms of concurrency, using the appropriate tool

for each part of the application.

1.2. Introduction to Asynchronous Programming

Asynchronous programming has two primary benefits. The first benefit is for end-user

GUI programs: asynchronous programming enables responsiveness. We’ve all used a

program that temporarily locks up while it’s working; an asynchronous program can

remain responsive to user input while it’s working. The second benefit is for server-side

programs: asynchronous programming enables scalability. A server application can

scale somewhat just by using the thread pool, but an asynchronous server application

can usually scale an order of magnitude better than that.

Modern asynchronous .NET applications use two keywords: async and await. The

async keyword is added to a method declaration, and its primary purpose is to enable

the await keyword within that method (the keywords were introduced as a pair for

backward-compatibility reasons). An async method should return Task<T> if it returns

a value, or Task if it does not return a value. These task types represent futures; they

notify the calling code when the async method completes.

Avoid

async void! It is possible to have an async method return

void, but you should only do this if you’re writing an async event

handler. A regular async method without a return value should

return Task, not void.

1.2. Introduction to Asynchronous Programming | 3

With that background, let’s take a quick look at an example:

async Task DoSomethingAsync()

{

int val = 13;

// Asynchronously wait 1 second.

await Task.Delay(TimeSpan.FromSeconds(1));

val *= 2;

// Asynchronously wait 1 second.

await Task.Delay(TimeSpan.FromSeconds(1));

Trace.WriteLine(val);

}

An async method begins executing synchronously, just like any other method. Within

an async method, the await keyword performs an asynchronous wait on its argument.

First, it checks whether the operation is already complete; if it is, it continues executing

(synchronously). Otherwise, it will pause the async method and return an incomplete

task. When that operation completes some time later, the async method will resume

executing.

You can think of an async method as having several synchronous portions, broken up

by await statements. The first synchronous portion executes on whetever thread calls

the method, but where do the other synchronous portions execute? The answer is a bit

complicated.

When you await a task (the most common scenario), a context is captured when the

await decides to pause the method. This context is the current SynchronizationCon

text unless it is null, in which case the context is the current TaskScheduler. The

method resumes executing within that captured context. Usually, this context is the UI

context (if you’re on the UI thread), an ASP.NET request context (if you’re processing

an ASP.NET request), or the thread pool context (most other situations).

So, in the preceding code, all the synchronous portions will attempt to resume on the

original context. If you call DoSomethingAsync from a UI thread, each of its synchronous

portions will run on that UI thread; but if you call it from a thread-pool thread, each of

its synchronous portions will run on a thread-pool thread.

You can avoid this default behavior by awaiting the result of the ConfigureAwait ex‐

tension method and passing false for the continueOnCapturedContext parameter.

The following code will start on the calling thread, and after it is paused by an await, it

will resume on a thread-pool thread:

async Task DoSomethingAsync()

{

int val = 13;

4 | Chapter 1: Concurrency: An Overview

剩余204页未读，继续阅读

xinconan2

粉丝: 269
资源: 399

掌握C#并发编程：实战指南

Concurrency in C# Cookbook mobi

Concurrency in C# Cookbook 原版（pdf+mobi）

Concurrency in C# Cookbook

Seven.Concurrency.Models.in.Seven.Weeks.2014.7.pdf

Java.Concurrency.in.Practice.pdf

Addison.Wesley.Java.Concurrency.in.Practice.May.2006.pdf

[Java并发编程实践].(Java.Concurrency.in.Practice).Brian.Goetz.英文原版.pdf

C++.Concurrency.in.Action

Manning.C++.Concurrency.in.Action.2012

[Java并发编程实践].(Java.Concurrency.in.Practice).Brian.Goetz.文字版(1).pdf

最新资源