利用C#构建多线程并行应用

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

"Csharp.Multithreaded.and.Parallel.Programming" 本书《C# 多线程与并行编程》由 Rodney Ringler 编著，是482页的英文版，由 Packt Publishing 在2014年12月24日出版，ISBN-10 为 184968832X，ISBN-13 为 9781849688321。这本书旨在帮助C#开发者充分利用现代多核硬件的优势，开发强大的多线程应用。书中详细介绍了如何利用Visual Studio的最新调试工具管理并调试同时运行的多个线程，以及如何在C#应用中运用Thread、Task和Parallel库。内容涵盖了从BackgroundWorker类到线程和任务，再到Async的多线程开发演变过程。目标读者是已经熟悉C#，但希望深入学习并发和多线程应用程序的.NET开发者，特别是对并行设计模式、线程、任务和async感兴趣的读者。全书分为11章，逐步引导读者掌握多线程编程技术： 1. 第一章介绍了多处理器和多核心的基本概念。 2. 第二章讨论了用于后台操作的BackgroundWorker类。 3. 第三章探讨了C#中的Thread类，即重量级并发。 4. 第四章深入讲解了高级线程处理技巧。 5. 第五章和第六章介绍了轻量级并发，即任务并行库(TPL)和基于任务的并行。 6. 第七章讲述了数据并行性，如何有效地利用多核进行数据处理。 7. 第八章讲解了如何使用Visual Studio调试多线程应用程序。 8. 第九章涵盖了管道和生产者-消费者设计模式，这是并行编程中的常见模式。 9. 第十章深入了并行LINQ(PLINQ)，一种简化查询并行化的技术。 10. 第十一章介绍了异步编程模型，这是C#中实现非阻塞I/O的关键技术。通过阅读本书，开发者可以了解到如何有效地利用C#和.NET Framework来构建能够充分利用多核硬件性能的应用程序，同时学习到如何避免和解决并发编程中的挑战，比如死锁、竞态条件等问题。此外，还能掌握Visual Studio的调试工具，以便于分析和优化多线程代码。这是一本全面而深入的指南，对于想要提升C#多线程和并行编程能力的开发者来说，是一份宝贵的参考资料。

Table of Contents

[ v ]

Producer-consumer design pattern 260

How to do it 261

How it works 266

Summary 269

Chapter 10: Parallel LINQ – PLINQ 271

Executing a PLINQ 272

How to do it 272

How it works 278

Ordering in PLINQ 279

How to do it 279

How it works 282

Merging in PLINQ 282

How to do it 284

How it works 288

Canceling a PLINQ 288

How to do it 288

How it works 290

Understanding performance improvements in PLINQ 291

Summary 296

Chapter 11: The Asynchronous Programming Model 297

Introduction to the Asynchronous Programming Model 298

How to do it 299

How it works 301

Using an AsyncCallback delegate method 303

How to do it 304

How it works 307

The async and await keywords 309

How to do it 310

How it works 313

Summary 316

Index 319

Preface

[ 2 ]

What this book covers

Chapter 1, Understanding Multiprocessing and Multiple Cores, covers the evolution

of computer hardware from single-processor systems to multiprocessor and

multiple-core systems. It will also discuss how the Windows Scheduler allots time

to threads. This chapter then discusses design considerations for concurrency,

how to take advantage of multiprocessor/multiple core systems, and the expected

performance improvements these designs can realize. During this chapter, we will

walk through a simple single-threaded and then multithreaded example to show

how performance is improved.

Chapter 2, Looking at Multithreaded Classes – BackgroundWorker, enables us to examine

the basics of multithreaded programming with the BackgroundWorker class. We

will go through a WPF example showing how we can update a UI while processing

is going on in the background. This chapter will discuss the basics of coordinating

work between multiple processes and the concept of concurrency.

Chapter 3, Thread Class – Heavyweight Concurrency in C#, allows us to examine and

work with the Thread class and namespace. We will learn how to create threads,

coordinate between threads, share data between threads, and stop threads. This

chapter will explore the idea of heavyweight concurrency versus lightweight

concurrency, which will be explained in detail later in the book. We will focus on

manually using and coordinating multiple threads in an application.

Chapter 4, Advanced Thread Processing, explains in detail the concept of heavyweight

concurrency and working with multiple threads using the Thread class. This

chapter will further expand the image processing application to demonstrate

how to coordinate between threads and wait on threads to complete by avoiding

deadlocks, locking, and error handling. This chapter will leave the reader with a

clear understanding of how to develop applications with multiple threads and have

complete control over their execution and interaction.

Chapter 5, Lightweight Concurrency – Task Parallel Library (TPL), introduces the Task

Parallel Library and the next evolution of multithreaded programming in C#/.NET.

Now that we have a full understanding of how to develop, manage, and control

applications with many threads, we will learn how to take advantage of the Parallel

namespace in .NET to do a lot of the heavy lifting for us. We will introduce the

idea of lightweight concurrency by leveraging the Parallel classes that .NET now

provides. This will allow us to focus more on designing an efcient and powerful

application and less on coordinating individual threads.

Chapter 6, Task-based Parallelism, enables us to examine the Task Parallel Library

and task parallelism. A task is an asynchronous set of operations that can be run

concurrently with other tasks. We will examine designing an application as a

Preface

[ 3 ]

series of tasks that can be performed in parallel. With the help of examples, we will

demonstrate how to create, manage, and coordinate tasks. We will further examine

additional topics with the Task Parallel Library and task parallelism. We will learn

how to perform exception handling when running multiple tasks, how to schedule

tasks under certain conditions, and how to cancel running tasks before they complete

when needed.

Chapter 7, Data Parallelism, explores the concept of data parallelism. We will see how

to perform the same operations on elements of a collection concurrently using the

Task Parallel Library. The Parallel class has the For and ForEach loops, and we will

show examples of each to demonstrate how they handle concurrent data processing.

We will convert our image processing application from heavyweight to lightweight

concurrency using the Task Parallel Library instead of the Thread class.

Chapter 8, Debugging Multithreaded Applications with Visual Studio, teaches us how

to take full advantage of Visual Studio 2012 to debug our multithreaded applications.

We will demonstrate using the Threads view, and the Tasks, Parallel Stacks,

and Parallel Watch windows. We will nish with debugging our image

processing application.

Chapter 9, Pipeline and Producer-consumer Design Patterns, helps us explore two of the

most popular parallel patterns for development—Pipelining and producer-consumer.

In Pipelining, we will see how to accomplish a parallel task where a simple parallel

loop will not work due to data dependencies. The producer-consumer pattern allows

a producer, which is generating results, to run along with the consumer so that the

consumer can consume the results concurrently. We will expand our image processing

application to implement these two patterns in combination.

Chapter 10, Parallel LINQ – PLINQ, details the benets and functionality provided

by Parallel LINQ (PLINQ). We will see how PLINQ speeds up traditional LINQs

by separating the data source into sections and executing the query on each section.

We will also discuss what kind of queries to use PLINQ for because not all queries

will run faster using PLINQ.

Chapter 11, The Asynchronous Programming Model, explains the Asynchronous

Programming Model (APM), which is a design pattern that is based on classes

implementing the IAsyncResult interface. We will see how to begin and end

asynchronous operations and use delegates to call methods asynchronously.

This chapter will also cover the new async and await keywords and how to

use them to implement an asynchronous design in your custom classes.

剩余344页未读，继续阅读

ramissue

粉丝: 354
资源: 1487

利用C#构建多线程并行应用

在.net4.0中使用Parallel并行运算的示例

C# Multithreaded and Parallel Programming 无水印pdf

C#使用Parallel类进行多线程编程实例

Wrox.Professional.Parallel.Programming.with.CSharp.Dec.2010.rar

Apress.Pro.dotNET.4.Parallel.Programming.in.CSharp.May.2010

Apress.Pro.dotNET.4.Parallel.Programming.in.CSharp.May.2010.rar

.net高级并行编程 Apress.Pro.dotNET.4.Parallel.Programming.in.CSharp.May.2010

Introduction.to.Game.Programming.Using.Csharp.and.Unity.3D

Packt.Mastering.Csharp.and.NET.Programming

Wrox.Functional.Programming.in.CSharp.Jun.2011

最新资源