并发世界的Erlang编程

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

"Programming Erlang - Software for a Concurrent World" 《Programming Erlang》是 Joe Armstrong 所著的一本关于 Erlang 编程语言的入门指南，它在并发编程领域具有较高的价值。Erlang 是一种专门为编写并发应用程序设计的语言，因此在处理多线程、分布式系统和高可用性应用方面具有显著优势。并发编程是现代软件开发中的一个关键概念，它允许程序同时执行多个任务，模仿现实世界中对象的行为。通过使用像 Erlang 这样的并发语言，开发者可以更轻松地构建出能够并行处理任务的系统，从而提高软件性能和效率。Erlang 的设计哲学是模仿人类思考和交互的方式，使得代码更加直观和易于理解。 Erlang 的主要特点包括： 1. **轻量级进程（Lightweight Processes）**：Erlang 中的进程非常轻便，消耗资源少，能快速创建和销毁，这使得在 Erlang 中实现并发变得简单而高效。 2. **消息传递（Message Passing）**：Erlang 进程之间的通信是通过异步的消息传递完成的，这种方式确保了进程间的隔离性和容错性。 3. **错误恢复与容错（Error Recovery and Fault Tolerance）**：Erlang 鼓励程序员编写能够容忍错误的代码，当某个进程失败时，可以通过重启该进程或使用备份进程来恢复服务，从而增强了系统的健壮性。 4. **热代码升级（Hot Code Swapping）**：Erlang 支持在运行时更新代码，无需停机，这对于需要保持高可用性的系统来说非常重要。 5. **函数式编程（Functional Programming）**：Erlang 是一种函数式编程语言，这意味着它强调不可变数据和纯函数，减少副作用，有助于编写简洁且易于测试的代码。 6. **分布式特性（Distributed Nature）**：Erlang 原生支持分布式计算，可以轻松地在多台机器上部署和扩展应用，适应大规模、分布式系统的需求。 7. **BEAM虚拟机（BEAM Virtual Machine）**：Erlang 运行在 BEAM 虚拟机上，它优化了并发执行和内存管理，为实时系统提供了良好的性能保障。 8. **模块化设计（Modular Design）**：Erlang 的模块化设计鼓励将大型系统分解为小的、独立的组件，便于维护和扩展。《Programming Erlang》这本书深入浅出地介绍了 Erlang 的语法、并发模型、进程通信、错误处理、模式匹配以及 OTP（Open Telecom Platform）框架等内容，对于想要进入 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页未读，继续阅读

skywalker

粉丝: 0
资源: 6

并发世界的Erlang编程

Programming Erlang.pdf

《Programming Erlang》

programming erlang src code

Programming Erlang second edition

Programming Erlang 2nd.pdf

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

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

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

Concurrent Programming in ERLANG

Erlang Programming

最新资源