Scala Actors权威指南：构建高效并发软件

4星 · 超过85%的资源需积分: 9 30 浏览量更新于2024-07-29 收藏 6.57MB PDF 举报

《Actors in Scala: Mar 2011》是由Scala标准库的创建者和主要维护者Philipp Haller与Frank Sommers合著的一本权威指南，专注于Scala的演员框架编程。这本书在多核时代并发编程领域具有重要意义，它为读者提供了一次全面的介绍，讲解了演员模型在并发软件开发中的应用以及如何利用Scala的演员系统构建高效、可扩展且健壮的并发应用程序，这些应用特别适合运行于Java虚拟机（JVM）上。本书的核心内容涵盖了演员的概念、原理和实践。作者通过详细的探讨，帮助读者理解如何设计和实现基于actor模型的并发程序，包括创建、通信和协调多个独立的执行实体，以实现线程安全和低延迟的分布式处理。书中的内容包括但不限于： 1. **演员（Actors）**：这部分深入解释了actor模型的基本概念，即轻量级的、自主的计算单元，它们独立执行任务并通过消息传递进行通信，有助于避免同步问题和提高系统的并行性。 2. **Scala语言特性**：书中展示了Scala如何利用其特质（traits）、模式匹配、函数式编程等特性，使得在actor模型中编程更加简洁和优雅。 3. **案例研究和示例**：作者通过实际项目的剖析，展示了如何在Scala中编写高效的actor程序，包括如何处理并发事件、错误处理和资源管理。 4. **多核时代的并发编程**：鉴于现代硬件的并行架构，本书强调了在多核心环境中利用actor模型进行并发编程的重要性，以及如何优化性能和扩展性。 5. **互动与反馈**：作为预印版，读者有机会参与到书的创作过程中，可以直接报告错误和提供改进建议，这反映了作者对读者参与和支持的重视。 6. **持续更新与最终出版**：购买者将能够获取到随着书稿进展的最新预印版，以及完成后发布的最终PDF版本，确保读者始终掌握最前沿的信息。《Actors in Scala》是一本实用的参考资料，对于希望利用Scala进行并发编程的开发者来说，无论是在学习理论还是实战操作层面，都有着极高的价值。通过阅读和实践书中的内容，读者将能提升在并发系统设计和实现方面的技能，并在不断发展的IT行业中保持竞争力。

Section 1.1 Chapter 1 · Concurrency Everywhere 15

processes. On another level, actors make concurrent programming gener-

ally simpler, because actors let developers focus on high-level concurrency

abstractions and shield programmers from intricacies that can easily lead to

errors. On an e v e n broader level, actors are about b u i l d i n g reliable programs

in a wo r ld where concurrency is the norm, not the e x c e p t i o n — a wor ld that

is fas t approaching.

This book aims to e x p l a i n actor-based programming with Scala on all

those levels. Before diving into the details of Scala actors, it helps to take a

step back and place actors in the context of other approaches to concurrent

programming, some of which may already be fam ilia r to you.

1.1 Scaling with concurrency

The mainstream computing architectures of the past decades focused on

making the e x e c u t i o n of a single thread of sequential instructions faste r. That

led to an application of Moore’s Law to computing performance: Processor

performance per unit cost has doubled roughly e v e r y eighteen months for the

last twenty years, and developers counted on that trend to ensure that their

increasingly complex programs performed well.

Moore’s Law has been remarkably accurate in predicting processor per-

formance, and it is reasonable to e x p e c t processor computing capacity to

double e v e r y one-and-a-half years for at least another decade. T o make that

increase practical, however, chip designers had to implement a major shift

in their design focus in recent years. Instead of trying to improve the clock

c y c l e s dedicated to e x e c u t i n g a single thread of instructions, new processor

designs make it possible to e x e c u t e many concurrent instruction threads on

a single chip. While the clock speed of each computing core on a chip is e x -

pected to improve only marginally o v e r the next few years, processors with

dozens of cores are already showing up in commodity servers, and multicore

chips are the norm e v e n in inexpensive desktops and notebooks.

This shift in the design of high-volume, commodity processor architec-

tures, such as the Intel x86, has at least two ramiﬁcations for developers.

First, because individual core clock c y c l e s will increase only modestly, we

will need to pay renewed attention to the algorithmic efﬁciency of sequential

code. Second, and more important in the context of actors, we will need to

design programs such that they take maximum advantage of a v a i l a b l e pro-

Sutter, “The free lunch is o v e r : A fundamental turn toward concurrency” [Sut05]

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Download from Wow! eBook <www.wowebook.com>

Section 1.2 Chapter 1 · Concurrency Everywhere 16

cessor cores. In other w o rds , we not only need to write programs that w o rk

correctly on concurrent hardware, b u t also design programs that opportunis-

tically scale to all a v a i l a b l e processing units or cores.

1.2 Actors v e r s u s threads

In a concurrent program, many independently e x e c u t i n g threads, or sequen-

tial processes, wor k together to fulﬁll an application’s requirements. Inves-

tigation into concurrent programming has mostly focused on deﬁning how

concurrently e x e c u t i n g sequential processes can communicate such that a

larger process—for e x a m p l e , a program that e x e c u t e d those processes—can

proceed predictably.

The two most common wa ys of communication among concurrent

threads are synchronization on shared state, and message passing. Many fa-

miliar programming constructs, such as semaphores and monitors, are based

on shared-state synchronization. Developers of concurrent programs are fa-

miliar with those structures. F o r e x a m p l e , Java programmers can ﬁnd these

structures in the

java.util.concurrent

library.

Among the biggest chal-

lenges for anyone using shared-state concurrency are a v o i d i n g concurrency

hazards, such as data races and deadlocks, and scalability.

Message passing is an alternative wa y of communication among coop-

erating threads. There are two important categories of systems based on

message passing. In channel-based systems, messages are sent to c h a n n e l s

(or ports) that processes can share. Several processes can then receive mes-

sages from the same shared channels. Examples of channel-based systems

are MPI

and systems based on the CSP paradigm

, such as the Go lan-

guage. Systems based on actors (or agents, or Erlang-style processes

) are in

the second category of message-passing concurrency. In these systems, mes-

Goetz et al., J a v a Concurrency in Practice [Goe06]

One of the reasons why scalability is hard to achieve using locks (or Java-style synchro-

nization) is the fa ct that coarse-grained locking increases the amount of code that is e x e c u t e d

sequentially. Moreover, accessing a small number of locks (or, in the e x t r e m e case, a single

global lock) from several threads may increase the cost of synchronization signiﬁcantly.

Gropp et al., Using MPI: P o r t a b l e P a r a l l e l Programming with the Message–Passing

Interface [Gro99]

Hoare, “Communicating sequential processes” [Hoa78]

Armstrong et al., Concurrent Programming in Erlang [Arm95]

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Download from Wow! eBook <www.wowebook.com>

Section 1.2 Chapter 1 · Concurrency Everywhere 17

sages are sent directly to actors; it is not necessary to create intermediary

channels between processes.

An important advantage of message passing o v e r shared-state concur-

rency is that it makes it easier to a v o i d data races. If processes communicate

only by passing messages, and those messages are immutable, then race con-

ditions are a v o i d e d by design. Moreover, anecdotal e v i d e n c e suggests that

this approach in practice also reduces the risk of deadlock. A potential dis-

advantage of message passing is that the communication o v e r h e a d may be

high. T o communicate, processes have to create and send messages, and

these messages are often b u f f e r e d in queues before they can be received to

support asynchronous communication. In contrast, shared-state concurrency

enables direct access to shared memory, as long as it is properly synchro-

nized. T o reduce the communication o v e r h e a d of message passing, large

messages should not be transferred by copying the message state; instead,

only a reference to the message should be sent. However, this reintroduces

the risk for data races when several processes have access to the same muta-

ble (message) data. It is an ongoing research effort to provide static checkers

(for instance, the Scala compiler plug-in for uniqueness types

that can v e r -

ify that programs passing mutable messages by reference do not contain data

races.

Let’s take a step back, and look at actor-based programming from a

higher-level perspective. T o appreciate the difference, and the relationship,

between more traditional concurrency constructs and actors, it helps to pay

a brief visit to the local railroad yard.

Imagine yourself standing on a bridge o v e r l o o k i n g the multitude of indi-

vidual tracks entering the rail yard. Y o u can observe many seemingly inde-

pendent activities taking place, such as trains arriving and leaving, cars being

loaded and unloaded and so on.

Suppose, then, that your job w a s to design such a railroad yard. Thinking

in terms of threads, locks, monitors, and so on, is similar to the problem of

ﬁguring out how to make sure that trains running on parallel tracks don’t

collide. It is a v e r y important requirement; without that, the rail yard w ould

be a dangerous place, indeed. T o accomplish that task, you wou ld employ

specialized artifacts, such as semaphores, monitors, switches.

Actors illuminate the same rail yard from the higher perspective of en-

suring that all the concurrent activities taking place at the rail yard progress

Haller and Odersky, “Capabilities for Uniqueness and Borrowing” [Hal10]

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Download from Wow! eBook <www.wowebook.com>

Section 1.3 Chapter 1 · Concurrency Everywhere 18

smoothly: that all the delivery v e h i c l e s ﬁnd their ways to train cars, all the

trains can make their progress through the tracks, and all the activities are

properly coordinated.

Y o u will need both perspectives when designing a rail yard: Thinking

from the relatively low-level perspective of individual tracks ensures that

trains don’t inadvertently cross paths; thinking from the perspective of the

entire fac ilit y helps ensure that your design fa c ili ates smooth o v e r a l l opera-

tion, and that your rail yard can scale, if needed, to accommodate increased

trafﬁc. Simply adding new rail tracks only goes so far: you need some o v e r -

all design principles to ensure that the whole rail yard can grow to handle

increased trafﬁc, and that greater trafﬁc can scale to the full capacity of the

tracks.

W o r k i n g on the relatively low-level details of individual tracks (or prob-

lems associated with interleaving threads), on the one hand, and the higher-

level perspective of the entire fac i lit y (actors) on the other, require somewhat

different skills and e x p e r i e n c e . An actor-based system is often implemented

in terms of threads, locks, monitors, and the like, b u t actors hide those low-

level details, and allow you to think of concurrent programs from a higher

v a n t a g e point.

1.3 The indeterministic soda machine

In addition to allowing you to focus on the scalability aspect of concurrent

applications, actors’ higher-level perspective on concurrency is helpful be-

cause it provides a more realistic abstraction for understanding how concur-

rent applications w ork. Speciﬁcally, concurrent programs e x h i b i t two char-

acteristics that, while also present in sequential applications, are especially

pronounced when a program is designed from the ground up to take advan-

tage of concurrency. T o see what these are, we need only to stop by the ofﬁce

soda machine.

A soda machine is convenient not only to quench our thirst on a hot

summer day, b u t also because it’s a good metaphor for a kind of program that

moves from one well-deﬁned state to another. T o start out, a soda machine

a w a i t s input from the user, perhaps prompting the user to insert some coins.

Inserting those coins causes the soda machine to enter a state where it can

now ask the user to make a selection of the desired drink. As soon as the user

Hoare, “Communicating sequential processes” [Hoa78]

Cover · Overview · Contents · Discuss · Suggest · Glossary · Index

Download from Wow! eBook <www.wowebook.com>

剩余138页未读，继续阅读

图灵的秘密

粉丝: 2
资源: 15

Scala Actors权威指南：构建高效并发软件

Artima.Akka.Concurrency

Programming in Scala

programming in Scala_ch

Programming in Scala, 2nd Edition

Programming+In+Scala+v3

将Java编译成JavaScript——Artima对话Google工程师Scott Blum.pdf

Scala_Scala编程

在Scala中进行编程：全面的分步指南Programming in Scala: A comprehensive step-by-step guide

Scala programing

Scala编程（第三版）中英文.zip

最新资源