并行编程艺术：Clay Breshears的并发指南

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

"《并发的艺术》是一本关于并行编程的重要参考资料，适合想要深入理解并行编程技术的读者。本书由Clay Breshears撰写，由O'Reilly Media出版，提供英文在线版本。" 正文: 《并发的艺术》是Clay Breshears的著作，该书针对并行编程领域提供了深入的见解和实用的知识。并行编程是现代计算中的关键领域，随着多核处理器和分布式系统的发展，理解和掌握并行编程技巧变得越来越重要。这本书为那些希望提升自己在并发编程方面能力的开发者提供了宝贵的资源。并行编程涉及多个执行单元同时处理任务，这可以显著提高计算效率，但同时也带来了复杂性和挑战，如线程同步、死锁、竞态条件等问题。书中可能涵盖了以下关键知识点： 1. **并发基础**：介绍并行与并发的概念，解释它们的区别，并讨论为什么需要并行编程。同时，可能会讲解单核与多核处理器的工作原理，以及操作系统如何调度任务。 2. **线程与进程**：详细阐述线程和进程的创建、管理以及它们之间的通信机制，包括共享内存、管道、套接字等。 3. **同步与互斥**：讲解如何使用锁、信号量、条件变量等机制来实现线程间的同步，防止竞态条件和数据不一致性。 4. **死锁**：分析死锁的产生原因，提供避免和解决死锁的策略，如资源预分配、银行家算法等。 5. **并发编程模型**：探讨各种并发编程模型，如线程池、事件驱动编程（如回调函数和异步I/O）、Actor模型等。 6. **并行算法**：介绍适用于并行环境的高效算法，如并行排序、并行搜索等，以及如何将传统算法转换为并行版本。 7. **分布式系统**：讲解如何在分布式环境中进行并行编程，包括网络通信、分布式数据存储和容错处理。 8. **编程语言支持**：讨论不同编程语言（如Java、C++、Python等）对并行编程的支持，包括语言特性和库函数。 9. **性能优化**：分析并行程序的性能瓶颈，提供性能监控和调优的方法，以及如何利用并行度最大化系统效率。 10. **案例研究与实践**：通过实际项目或案例，展示并行编程在真实场景中的应用，帮助读者巩固理论知识并提高实践能力。本书适合有一定编程基础，希望通过并行编程提高代码效率的开发人员阅读。它不仅可以帮助读者理解并行编程的基本概念，还能提供解决实际问题的工具和策略。通过学习《并发的艺术》，开发者能够更好地驾驭复杂的并发环境，编写出高效且可靠的并行应用程序。

“[A]nd in this precious phial is the power to think twice

as fast, move twice as quickly, do twice as much work in

a given time as you could otherwise do.”

—H. G. Wells, “The New Accelerator” (1901)

WITH THIS BOOK I WANT TO PEEL BACK THE VEILS OF MYSTERY , MISERY, AND misunderstanding

that surround concurrent programming. I want to pass along to you some of the tricks, secrets,

and skills that I’ve learned over my last two decades of concurrent and parallel programming

experience.

I will demonstrate these tricks, secrets, and skills—and the art of concurrent programming—

by developing and implementing concurrent algorithms from serial code. I will explain the

thought processes I went through for each example in order to give you insight into how

concurrent code can be developed. I will be using threads as the model of concurrency in a

shared-memory environment for all algorithms devised and implemented. Since this isn’t a

book on one specific threading library, I’ve used several of the common libraries throughout

and included some hints on how implementations might differ, in case your preferred method

wasn’t used.

Like any programming skill, there is a level of mechanics involved in being ready and able to

attempt concurrent or multithreaded programming. You can learn these things (such as syntax,

methods for mutual exclusion, and sharing data) through study and practice. There is also a

necessary component of logical thinking skills and intuition needed to tackle or avoid even

simple concurrent programming problems successfully. Being able to apply that logical

thinking and having some intuition, or being able to think about threads executing in parallel

with each other, is the art of concurrent and multithreaded programming. You can learn some

of this through demonstration by experts, but that only works if the innate ability is already

there and you can apply the lessons learned to other situations. Since you’ve picked up this

volume, I’m sure that you, my fine reader, already possess such innate skills. This book will

help you shape and aim those skills at concurrent and multithreaded programming.

Some Questions You May Have

Before we get started, there are some questions you may have thought up while reading those

first few paragraphs or even when you saw this book on the shelves before picking it up. Let’s

take a look at some of those questions now.

What Is a Thread Monkey?

thread monkey

is a programmer capable of designing multithreaded, concurrent, and parallel

software, as well as grinding out correct and efficient code to implement those designs. Much

like a “grease monkey” is someone who can work magic on automobiles, a thread monkey is

2 C HA PT ER 1 : W AN T TO G O FA ST ER ? RA IS E YO UR H AN DS I F YO U WA NT T O GO F AS TE R!

a wiz at concurrent programming. Thread monkey is a title of prestige, unlike the often

derogatory connotations associated with “code monkey.”

Parallelism and Concurrency: What’s the Difference?

The terms “parallel” and “concurrent” have been tossed around with increasing frequency

since the release of general-purpose multicore processors. Even prior to that, there has been

some confusion about these terms in other areas of computation. What is the difference, or

there a difference, since use of these terms seems to be almost interchangeable?

A system is said to be

concurrent

if it can support two or more actions

in progress

at the same

time. A system is said to be

parallel

if it can support two or more actions executing

simultaneously. The key concept and difference between these definitions is the phrase “in

progress.”

A concurrent application will have two or more threads in progress at some time. This can

mean that the application has two threads that are being swapped in and out by the operating

system on a single core processor. These threads will be “in progress”—each in the midst of its

execution—at the same time. In parallel execution, there must be multiple cores available

within the computation platform. In that case, the two or more threads could each be assigned

a separate core and would be running simultaneously.

I hope you’ve already deduced that “parallel” is a subset of “concurrent.” That is, you can write

a concurrent application that uses multiple threads or processes, but if you don’t have multiple

cores for execution, you won’t be able to run your code in parallel. Thus,

concurrent

programming

and

concurrency

encompass all programming and execution activities that

involve multiple streams of execution being implemented in order to solve a single problem.

For about the last 20 years, the term

parallel programming

has been synonymous with

message-passing or distributed-memory programming. With multiple compute nodes in a

cluster or connected via some network, each node with one or more processors, you had a

parallel platform. There is a specific programming methodology required to write applications

that divide up the work and share data. The programming of applications utilizing threads has

been thought of as concurrent programming, since threads are part of a shared-memory

programming model that fits nicely into a single core system able to access the memory within

the platform.

I will be striving to use the terms “parallel” and “concurrent” correctly throughout this book.

This means that

concurrent programming

and

design of concurrent algorithms

will assume

that the resulting code is able to run on a single core or multiple cores without any drastic

changes. Even though the implementation model will be threads, I will talk about the parallel

execution of concurrent codes, since I assume that we all have multicore processors available

on which to execute those multiple threads. Also, I’ll use the term “parallelization” as the

process of translating applications from serial to concurrent (and the term “concurrentization”

doesn’t roll off the tongue quite as nicely).

S om e Qu es ti on s Yo u Ma y Ha ve 3

Why Do I Need to Know This? What’s in It for Me?

I’m tempted to be a tad flippant and tell you that there’s no way to avoid this topic; multicore

processors are here now and here to stay, and if you want to remain a vital and employable

programmer, you have no choice but to learn and master this material. Of course, I’d be waving

my hands around manically for emphasis and trying to put you into a frightened state of mind.

While all that is true to some degree, a kinder and gentler approach is more likely to gain your

trust and get you on board with the concurrent programming revolution.

Whether you’re a faceless corporate drone for a large software conglomerate, writing code for

a small in-house programming shop, doing open source development, or just dabbling with

writing software as a hobby, you are going to be touched by multicore processors to one degree

or another. In the past, to get a burst of increased performance out of your applications, you

simply needed to wait for the next generation of processor that had a faster clock speed than

the previous model. A colleague of mine once postulated that you could take nine months off

to play the drums or surf, come back after the new chips had been released, run some

benchmarks, and declare success. In his seminal (and by now, legendary) article, “The Free

Lunch Is Over: A Fundamental Turn Toward Concurrency in Software” (

Dr. Dobb’s Journal

March 2005), Herb Sutter explains that this situation is no longer viable. Programmers will

need to start writing concurrent code in order to take full advantage of multicore processors

and achieve future performance improvements.

What kinds of performance improvements can you expect with concurrent programming on

multicore processors? As an upper bound, you could expect applications to run in half the time

using two cores, one quarter of the time running on four cores, one eighth of the time running

on eight cores, and so on. This sounds much better than the 20–30% decrease in runtime when

using a new, faster processor. Unfortunately, it takes some work to get code whipped into shape

and capable of taking advantage of multiple cores. Plus, in general, very few codes will be able

to achieve these upper bound levels of increased performance. In fact, as the number of cores

increases, you may find that the relative performance actually decreases. However, if you can

write good concurrent and multithreaded applications, you will be able to achieve respectable

performance increases (or be able to explain why you can’t). Better yet, if you can develop

your concurrent algorithms in such a way that the same relative performance increases seen

on two and four cores remains when executing on 8, 16, or more cores, you may be able to

devote some time to your drumming and surfing. A major focus of this book will be pointing

out when and how to develop such

scalable

algorithms.

Isn’t Concurrent Programming Hard?

Concurrent programming is no walk in the park, that’s for sure. However, I don’t think it is as

scary or as difficult as others may have led you to think. If approached in a logical and informed

fashion, learning and practicing concurrent programming is no more difficult than learning

another programming language.

4 C HA PT ER 1 : W AN T TO G O FA ST ER ? RA IS E YO UR H AN DS I F YO U WA NT T O GO F AS TE R!

剩余303页未读，继续阅读

jia1546

粉丝: 3
资源: 18

并行编程艺术：Clay Breshears的并发指南

掌握并发艺术：《The Art of Concurrency》深度解析

并发编程艺术：线程猴子的并行应用指南

并发编程的艺术：探索 Clay Breshears 的视角

The Art of Concurrency

The Art of Concurrency.pdf

并发的艺术the art of concurrency

并发的艺术 英文版(开发并行代码算法程序员必备手册 ) The Art of Concurrency: A Thread Monkey's Guide to Writing Parallel Applications

javaconcurrent源码-The-Art-of-Concurrency-Programming:TheArtofJavaConcurr

The Art of Assembly Language Programming

the-art-of-java-concurrency-programming:Java并发编程的艺术原始代码

最新资源

并发的艺术英文版(开发并行代码算法程序员必备手册 ) The Art of Concurrency: A Thread Monkey's Guide to Writing Parallel Applications