C#并发编程实战指南：高清彩版

需积分: 9 152 浏览量更新于2024-07-18 2 收藏 4.57MB PDF 举报

"高清彩版 Concurrency in C# Cookbook: 由 Stephen Cleary 撰写，本书涵盖了 C# 语言中的并发与多线程技术，包括反应式编程模型和并行处理等内容。这本书获得了 Scott Hanselman、Jon Skeet 和 Stephen Toub 等业界专家的高度评价，是现代 .NET 并发的理想参考书。" 在编程领域，尤其是 C# 开发中，处理并发性和多线程是至关重要的技能。随着硬件性能的不断提升，多核处理器变得越来越常见，使得开发者可以利用更多的计算资源。然而，如何有效地利用这些资源并编写出高效、安全的并发代码仍然是一项挑战。"Concurrency in C# Cookbook" 旨在解决这个问题，帮助开发者更好地理解和应用并发技术。作者 Stephen Cleary 是 C# 并发和异步编程领域的权威，他在书中深入浅出地介绍了以下几个关键知识点： 1. **并发基础**：介绍并发的基本概念，包括线程、进程以及它们之间的交互。理解这些基础知识对于设计并发程序至关重要。 2. **线程管理**：讨论如何创建和管理线程，包括线程池的使用，以及如何通过线程同步机制（如锁、监视器、信号量等）避免数据竞争问题。 3. **异步编程**：C# 提供了基于任务的异步模型（TAP），通过 `async` 和 `await` 关键字简化了异步代码的编写。书中会详细讲解如何正确使用这些关键字，以及如何处理异步操作的错误和取消。 4. **并行编程**：介绍如何使用 .NET Framework 的并行 LINQ (PLINQ) 和 Task Parallel Library (TPL) 来并行处理数据，提升程序的执行效率。 5. **反应式编程**：解释反应式扩展（Reactive Extensions, Rx）的概念，这是一种处理异步数据流的方式，可以用于创建响应式、事件驱动的程序。 6. **并发模式和策略**：探讨各种并发模式，如生产者消费者模型、工作窃取算法等，并提供实际代码示例，帮助读者掌握在不同场景下选择合适策略的方法。 7. **性能优化**：讨论如何通过合理的并发设计来提高程序性能，同时避免过度并发导致的问题，如上下文切换开销。 8. **调试和测试**：介绍如何在并发环境中调试和测试代码，以确保其正确性和健壮性。 "Concurrency in C# Cookbook" 采用易于阅读的格式，提供了丰富的实例和实践指导，无论你是初学者还是有经验的开发者，都能从中受益，提升你在 C# 并发编程方面的专业技能。

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

acDonald, 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 m

ultithreading. 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

plies 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页未读，继续阅读

weixin_38669689

粉丝: 27
资源: 300

C#并发编程实战指南：高清彩版

Concurrency in C# Cookbook mobi

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

Concurrency in C# Cookbook

Concurrency in C# Cookbook epub

Concurrency in C# Cookbook 无水印pdf

Concurrency in C# Cookbook （原版）

O'Reilly.Concurrency in C# Cookbook.2014

￼Transactions: Concurrency Control and Recovery: Optimist concurrency control

java8源码-learn-java-concurrency::pizza:并发操作合集系列

Concurrency in Go: Tools and Techniques for Developers

最新资源

Transactions: Concurrency Control and Recovery: Optimist concurrency control