C#并发编程实战指南

需积分: 8 134 浏览量更新于2024-07-17 收藏 4.78MB PDF 举报

"Concurrency in C# Cookbook.2014.pdf 是一本由Stephen Cleary编写的英文书籍，专注于介绍如何在C#编程语言中处理并发和多线程问题。本书涵盖了广泛的并发技术，包括线程、反应式编程模型、并行处理等，并采用易于理解的实践指南（cookbook）形式呈现，旨在帮助开发者更好地理解和应用这些现代.NET并发技术。书评人包括Scott Hanselman（微软的ASP.NET和Azure Web Tools首席项目经理）、Jon Skeet（谷歌的高级软件工程师）和Stephen Toub（微软的首席架构师），他们对这本书给予了高度评价，认为它是.NET并发的理想参考书。" 在C#编程中，并发是至关重要的一个主题，特别是随着硬件性能的提升和多核处理器的普及，开发者需要有效地利用计算资源，实现高效的并行处理。这本书将深入探讨以下几个关键知识点： 1. **线程管理**：学习如何创建和管理线程，包括线程同步、线程池以及如何避免常见的并发问题，如死锁和竞态条件。 2. **异步编程**：C#引入了异步编程模型，如`async`和`await`关键字，使得编写非阻塞的I/O密集型操作变得简单。书中会详细解释这些概念和用法。 3. **并发原语**：理解并使用各种并发原语，如`Mutex`、`Semaphore`、`Monitor`以及`lock`语句，这些工具用于控制对共享资源的访问。 4. **反应式编程**：了解反应式扩展（Reactive Extensions, RX）框架，它允许开发者通过声明式方式处理异步数据流，提高代码的可读性和可维护性。 5. **并行 LINQ (PLINQ)**：掌握并行查询的概念，利用PLINQ加速数据处理，充分利用多核处理器的潜力。 6. **任务并行库(TPL)**：学习如何使用任务并行库来创建并行任务，以及如何使用`Task`类来管理并发任务。 7. **错误处理和调试**：在并发环境中，错误处理和调试显得尤为重要。书中将介绍如何在并发程序中识别和解决问题。 8. **性能优化**：讨论如何评估和优化并发代码的性能，包括避免过度同步和资源争抢。 9. **设计模式**：了解适用于并发编程的设计模式，如生产者消费者模型、工作窃取算法等，以实现高效且可扩展的系统。 10. **并发与多线程的最佳实践**：指导读者遵循最佳实践，以确保并发代码的正确性和可维护性。通过这本书，开发者能够掌握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页未读，继续阅读

brucejing2

粉丝: 0
资源: 21

C#并发编程实战指南

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

Concurrency in C# Cookbook 无水印pdf

guava-30.0-jre.jar

springboot 生产者kafka 死信队列

如何修改DataX的datax.py的运行参数

java 外文参考文献_java英文参考文献

openeuler安装openstack

concurrency in action, 2nd edition.pdf

最新资源