并发编程：Erlang实战指南

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

"这本书《Programming Erlang》由Erlang语言的发明者Joe Armstrong撰写，是一本关于并发世界的软件编程指南。书中强调使用Erlang这样的并发应用设计语言可以简化开发过程，帮助程序员构建出与现实世界行为相仿的程序。" 在《Programming Erlang》中，作者Joe Armstrong探讨了并发编程的重要性以及为何Erlang是解决这类问题的理想选择。并发编程是指一个系统中的多个执行单元同时工作，这种模型模拟了现实世界中许多实体并行交互的情况。Erlang是一种函数式编程语言，最初由爱立信设计，特别适合构建高度并发、分布式和容错的系统。书中的内容可能涵盖了以下几个主要知识点： 1. **Erlang语言基础**：Erlang的语法特性，包括过程、模式匹配、函数式编程的哲学，以及如何通过Erlang的轻量级进程（Lightweight Processes, LPs）实现并发。 2. **并发编程模型**：解释Erlang的并发模型，如进程间的通信（Message Passing），以及如何避免共享状态以减少错误和提高系统的可靠性。 3. **故障恢复与容错**：Erlang如何通过分布式节点和错误检测机制来构建高可用性系统，允许系统在部分故障时仍能继续运行。 4. **并发编程的最佳实践**：书中可能包含编写高效并发代码的技巧和陷阱，比如如何避免阻塞，以及如何有效地管理进程间的同步和协作。 5. **实时系统设计**：Erlang适用于实时系统，因为它具有低延迟和高吞吐量的特性，书中可能涉及如何设计和实现这些系统。 6. **Erlang OTP框架**：OTP（Open Telecom Platform）是Erlang的标准库，提供了模块化的设计模式，如GenServer、GenEvent等，用于构建可复用且可靠的组件。 7. **案例研究**：书中可能会用实际的Erlang项目或应用作为示例，展示如何在现实世界中应用并发编程思想和Erlang语言。 8. **调试和测试**：Erlang的调试工具和测试策略，如如何进行进程监控，以及如何确保并发代码的正确性。 9. **性能优化**：讨论Erlang程序的性能瓶颈，以及如何通过调整代码和系统配置来提升性能。 10. **与其他技术的集成**：Erlang可以与其他语言和技术集成，如如何通过Erlang NIF（Native Implemented Function）调用C代码，或者如何与Java和Web服务进行交互。通过《Programming 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页未读，继续阅读

countercat

粉丝: 0
资源: 1

并发编程：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

最新资源