并发编程：Erlang实战指南

需积分: 20 184 浏览量更新于2024-07-28 收藏 2.65MB PDF 举报

"Programming Erlang" 是一本由Erlang的创造者Joe Armstrong编写的关于Erlang编程语言的专业书籍，旨在帮助读者理解并发编程的世界。在当今的计算环境中，世界是并行的。为了编写出能够模拟现实世界中对象行为的程序，我们需要采用具有并发结构的软件设计。Erlang就是这样一种专为并发应用程序设计的语言，它使得开发过程变得更加简单和高效。通过使用Erlang，程序员可以更自然地表达思维模式和交互方式。这本书——"Programming Erlang: Software for a Concurrent World"——深入探讨了Erlang语言的核心特性，如轻量级进程、消息传递、容错性和分布式计算。Erlang的轻量级进程使得创建大量并发实体成为可能，而这些实体可以独立执行任务并互相通信。消息传递机制是Erlang并发模型的基础，它允许进程之间以异步的方式交换数据，提高了系统的可扩展性和可靠性。 Joe Armstrong通过这本书向读者展示了如何利用Erlang构建高度可靠和容错的系统。Erlang的设计理念强调了系统的健壮性，即使在单个组件失败的情况下，系统也能继续运行。这在构建高可用性的服务和分布式系统中尤为重要。书中还涵盖了Erlang的其他关键概念，如模式匹配、函数式编程、类型系统以及错误处理策略。函数式编程的特性让Erlang代码更加简洁和易于理解，同时减少了状态变化带来的复杂性。类型系统虽然不是静态的，但提供了足够的工具来进行类型检查，确保了代码的正确性。此外，"Programming Erlang"也讨论了Erlang的模块化和 OTP（开放电信平台，Open Telecom Platform）框架，这是Erlang生态系统的一部分，提供了构建大型、可维护系统的最佳实践。OTP包括了一系列库和服务，用于监控、管理和恢复系统组件，进一步增强了Erlang在构建大规模并发系统中的能力。 "Programming Erlang" 是一本全面介绍并发编程和Erlang语言的指南，无论你是初学者还是有经验的开发者，都能从中受益，学习如何构建适应并发世界的高效软件。通过阅读本书，你将学会如何利用Erlang的强项来解决实际问题，设计和实现高性能、可扩展的系统。

BEGIN AGAIN 16

• Appendix E, on page 419, looks at techniques for analyz i ng, pro-

ﬁling, debugging, and tracing your code.

• Appendix

F, on page 439, has one-line summaries of the most

used modules in the Erlang standard librari es.

1.2 Begin Again

Once upon a time a programmer came across a book describing a funny

programming language. It had an unfamiliar syntax, equal didn’t mean

equals, and variables weren’t allowed to vary. Worse, it wasn’t even

object-oriented. The programs were, well, different....

Not only were the programs different, but the whole approach to pro-

gramming was different. The author kept on and on about concurrency

and distribution and fault tolerance and about a method of programming

called concurrency-oriented programming—whatever that might mean.

But some of the examples looked like fun. That evening the programmer

looked at the example chat program. I t was pretty small and easy to

understand, even if the syntax was a bit strange. Surely it couldn’t be

that easy.

The basic program was simple, and with a few mo re lines of code, ﬁle

sharing and encrypted conversations became possible. The programmer

started typing....

What’s This All About?

It’s about concurrency. It’s about distribution. It’s about fault toler-

ance. It’s about functional programming. It ’s about programming a dis-

tributed concurrent system without l ocks and mutexes but using only

pure message passing. It ’s about speeding up your programs on multi-

core CPUs. It’s about writing distributed applications that allow people

to in teract with each other. It’s about design methods and behaviors

for writing fault-tolerant and distributed systems. It’s about modeling

concurrency and mapping those models onto computer programs, a

process I call concurrency-oriented programming.

I had fun writing this book. I hope you have fun reading it.

Now go read the book, write some code, and have fun.

ACKNOWLEDGMENTS 17

1.3 Acknowledgments

Many people have helped in the preparation of this book, and I’d like to

thank them all here.

First, Dave Thomas, my editor: Dave h as been teaching me to write

and subjecting me to a barr age of never-ending questions. Why this?

Why that? When I star ted the book, Dave said my writing style was like

“standing on a rock preaching.” He said, “I want you to talk to people,

not preach.” The book is better for it. Thanks, Dave.

Next, I’ve had a little committee of language experts at my back. They

helped me decide what to leave out. They also helped me clarif y some

of the bits that are difﬁcult to explain. Thanks here (in no particular

order) to Björn Gustavsson, Robert Virding, Kostis Sagonas, Kenneth

Lundin, Richard Carlsson, and Ulf Wiger.

Thanks also to Claes Vikström who pr ovided valuable advice on Mnesia,

to Rickard Green on SMP Erlang, and to Hans Nilsson for the ste mmi ng

algorithm used in the text-indexing program.

Sean Hinde and Ulf Wiger helped me understand how to use various

OTP internals, and Serge Aleynikov explained acti ve sockets to me so

that I could understand.

Helen Taylor (my wife) has proofread several chapters and provided

hundreds of cups of tea at appropriate moments. Wh at’s more, she put

up with my rather obsessive behavior for the last seven months. Thanks

also to Thomas and Claire; and thanks t o Bach and Handel, Zorro and

Daisy, and Doris, who have helped me stay sane, have purred when

stroked, and have gotten me to the right addresses.

Finally, to all the readers of the beta book who ﬁlled in errata requests:

I have cursed y ou and praised you. When the ﬁrst beta went out, I was

unprepared for the entire book to be read in two days and for you to

shred every page with your comments. But the process has resulted in

a much better book than I had imagined. When (as happened several

times) dozens of people said, “I don’t understand this page,” then I was

forced to think again and rewrite the mater i al concerned. Thanks for

your help, everybody.

Joe Armstrong

May 2007

OVERVIEW 19

At this stage you’ll be familiar with Erlang, so we’ll move on to more

interesti ng topics:

• You’ll pick up more advanced uses of the shell. The shell can do a

lot more th an we let on when you were ﬁrst learning it. ( For exam-

ple, you can recall and edit previous expressions. This is covered

in Section

6.5, Command Editing in the Erlang Shell, on page 130.)

• You’ll start learning the libraries (called modules in Erlang). Most

of the programs I write can be w ritten using ﬁve modules: lists, io,

ﬁle, dict, and gen_tcp; therefore, we’ll be using these modules a lot

throughout the book.

• As your programs get bigger, you’ll need to learn how to automate

compiling and running them. The tool of choice for this is make.

We’ll see how to control the process by writing a makeﬁle. This is

covered in Section

6.4, Automating Compilation with Makeﬁles, on

page 127.

• The bigger world of Erlang programming uses an extensive library

collection called OTP.

As you gain experience with Erlang, you’ll

ﬁnd that knowing OTP will save you l ots of time. After all, wh y

reinvent the wheel if someone has already written the functional-

ity you need? We’ll learn th e major OTP behaviors, in particular

gen_server. This is covered in Section

16.2, Getting Started with

gen_server, on page

301.

• One of the main uses of Erlang is writing distributed programs,

so now is the time to start experimenting. You can start with the

examples in Chapter 10, Distributed Programming, on page 175,

and you can extend them in any way you want.

Stage 2.5: I May Learn Some Optional Stuff

You don’t have to read every chapter in this book the ﬁrst time through.

Unlike most of the languages you have probably met before, Erlang is

a concurrent programming language—this makes it particularly suited

for writing distributed programs and for programming modern mult i -

core and SMP

computers. Most Erlang programs will just run faster

when run on a multicore or SMP machine.

Erlang programming in volves using a programming paradigm that I call

concurrency-oriented programming (COP).

1. Open Telecom Platform.

2. Symmetric multiprocessing.

剩余518页未读，继续阅读

damngooder

粉丝: 0
资源: 2

并发编程：Erlang实战指南

erlang programming

Programming Erlang 2nd.pdf

《Programming Erlang》

programming erlang src code

Programming Erlang.pdf

Programming Erlang second edition

并发世界中的Erlang编程：Programming Erlang解析

使用Erlang编写高效并发程序：Programming Erlang(2nd版)

并发编程利器：Programming Erlang.pdf解读

Concurrent Programming in ERLANG

最新资源