Erlang 中文编程入门教程（下）

Erlang 是一种多用途的编程语言，主要用于开发并行和分布式系统。本系列文章的第 1 部分介绍了 Erlang 及其函数编程风格与其他编程范式的对比情况，例如命令式、过程和面向对象的编程。在第 2 部分中，您将使用部分高级特性和功能，首先从基本函数开始，随后介绍并行编程、进程和消息传递。这些内容结合在一起，共同支持分布式编程，也就是 Erlang 的一种强大的特性。

并行编程

实现在一个程序内同时执行多个进程的能力（而非同时运行多个程序）始终要求人们改变使用传统函数编程语言时的编程方法。这种并行性（或多线程）问题在于确保您希望为其更新信息的线程，仅影响正在处理的数据和信息。举例来说，您不希望一个更新单个文件的进程多次执行，因为这可能带来文件在处理过程中被损坏的风险。

Erlang 采用了使所有程序保持并行的方法，而且组件（函数和模块）均不共享数据。数据使用消息在组件之间交换。利用消息可限制独立组件修改数据的方式，从而有助于消除并行数据修改问题。这种方法不再直接更改数据，而是发送消息来更新数据，因此也使隔离和并行更新更为困难。Erlang 还遵循操作必将失败的原则，因此提供了一种能够处理错误并在必要时从中恢复的系统。

Erlang 在内部通过创建称为进程的小型轻量级执行来处理并行性问题。不同于 C 等其他主流语言，这些进程并非构建在本地操作系统进程或线程模型之上，而是由 Erlang 虚拟机内部创建和管理。这允许各进程在内存和 CPU 需求方面比本地 OS 线程更为轻量。此外，由于 Erlang 通过自动创建和使用众多小型进程执行操作，因此即便相对较为简单的程序往往也要运行成千上万个甚至数百万个进程。

并行模型内置于 Erlang 之中，因此大量进程的管理是 Erlang 工作方式的关键组成部分。用于在进程间发送数据的消息传递系统也采用了内置形式，并设计为以非常有效的方式向任意进程分发消息，而无论当前正在运行的进程的数量如何。作为消息实现的一种附带收益，消息不仅可内部发送，还可跨网络发送，允许 Erlang 跨多个实例共享消息，从而支持多台机器间的分布式编程。

进程

Erlang 进程系统是轻量级的，进程的创建直观而简单，由于不存在开销，因此也几乎没有理由担心其影响。这就意味着您可以出于任何对应用程序有益的原因来创建新进程。

在实践中，您可以调用内置函数 spawn() 来创建进程，其调用结构如下： PID = spawn(module, function, arguments)，其中 module 是模块名称、function 是函数名称、arguments 是要提供给函数的参数列表。返回值（上例中的 PID）是进程标识符。

举例来说，在本系列上一期文章中，可以使用以下格式将我们创建的 Fibonacci 函数作为新进程调用：PID = spawn(fib,printfibo,[10])。

请注意，spawn() 的最后一个参数是仅有一个元素的列表，而非在直接调用函数时使用的单一参数。结果是一个新进程，将按照调用函数的方式来执行函数： fib:printfibo(10)。

spawn() 创建的新进程将在终止之前继续执行，可能正常终止（即无错误），也可能非正常终止（即发生了某些错误）。

实际的生成进程本身不会失败，即便您调用的函数不存在也是如此。这能减少在代码中测试生成进程的需要。除了 Erlang shell 中的错误以外，其他进程中的错误将由错误记录程序处理和记录，这是一个处理错误报告的内置进程。

在典型使用中，进程用于支持并行性。在上述 Fibonacci 样例中，在另一个进程内运行printfibo() 函数不会得到有用的返回值。但是，如果您希望生成一个新进程，例如基本 fibo()函数，同时向该进程发送信息并接收该进程提供的信息，又该如何？

内置的消息传递系统可处理这样的交互。

消息传递

Erlang 中的消息传递系统是 Erlang 执行环境的另一个内置部分，它与进程系统协同工作，支持有效地交换数据和消息。

每个进程都将获得一个“邮箱”，其他进程可向此邮箱发送消息。消息按照发送顺序存储，也就是说如果您从一个进程向另一个进程依次发送 A 和 B 两条消息，则消息 A 将先显示在邮箱中，消息 B 紧随其后。由于进程系统有着并行的本质，因此除了同一个进程发送的消息的独立顺序之外，多个进程发送到单独一个进程的多条消息的顺序不会按照任何特定方式排序。

要向一个进程发送一条消息，您需要了解希望与之通信的进程的进程 ID。随后可使用结构： Pid ! Message，其中 Pid 是进程 ID， Message是任意 Erlang 数据类型。

要从一个进程内接收一条消息，可使用 receive 语句。在 receive 语句内，使用模式匹配根据消息内容来确定要执行哪些操作。如果匹配成功，则从邮箱接收消息，消息参数通过绑定到匹配中的变量提供，并执行相应的子句。

举例来说，根据提供 “store” 原子（atom）和一个值的消息进行匹配的代码，如清单 1 所示。

清单 1. 使用 `receive` 语句从一个进程内接收一条消息

receive
    {store, Value} -> store(Value),
    {get, Value} -> get(Value)
end

在本例中，代码使用模式匹配来匹配左侧的原子和变量，随后在右侧执行操作，本例中即根据消息内容存储值并获取值。

receive 语句将暂停进程中的执行，确保进程等待至新消息传入，之后再执行操作。典型的例子就是存储一个可以在多个进程之间共享的变量的基本操作。

通常，在应用程序内，您要将 receive 语句用作循环的一部分，循环渐进地读取发送给进程的新消息，并执行独立操作。Erlang 不具备传统意义上的循环，正如第一部分的 Fibonacci 示例（请参见参考资料）所示；您需要编写一个函数，调用自身来处理消息（请参见清单 2）。

清单 2. 调用自身来处理下一条消息的函数

dbrequest() ->
    receive
        {store, Value} -> store(Value),
        {get, Value} -> get(Value)
    end

在传统并行环境中，您可以使用信号量这样的解决方案，允许进程确定一个变量是否 “处于使用中”，还是可更新。在许多环境中，信号量都给尝试更新相同值的各进程带来了等待时间，这可能会延迟程序的执行。在 Erlang 中，您可以将一个操作包含在一个进程内，随后利用消息传递来处理更新。由于消息的接收采用了队列的形式，因此可以依次处理每条消息，从而独立执行各个操作，如图 1 所示。

图 1. 使用消息传递处理相同值的更新

这种基本的并行和消息传递结构是多种不同应用程序的基础。例如，Facebook 为 Facebook 消息传递使用了消息环境。以 MochiWeb 提供自身的 Web 界面且基于文档的数据库 CouchDB 则利用进程和消息传递系统来确保正确处理数据库更新和响应，而不会造成其他数据库往往存在的常见并行更新问题。

消息传递，尤其是在与并行处理结合时，可使程序顺序处理信息，即便存在来自不同位置的多个请求时也是如此。这解决了其他语言中典型并行编程的主要问题之一，使数据和操作可共享，而不必担心损坏或破坏进程中的信息。这种方法能够消除大多数并行编程问题存在的主要难题之一。

然而，在解决扩展解决方案、提高性能的问题方面，尤其是在现代网络和 Web 应用程序中，并行性只能为您提供这种程度的帮助。最终，您将需要多台服务器。幸运的是，Erlang 同样为这种分布式编程问题提供了解决方案。

分布式编程

Erlang 中的分布式编程基于一台简单的网络服务器和本文前述的消息传递系统构建，旨在提供发送和接收消息的机制，更重要的是，支持本地 RPC 和 Web 服务等环境支持的那类远程过程调用。

值得注意的是，分布式不一定表示不同的机器，也可能是希望彼此沟通并共享信息或操作的两个不同的 Erlang 应用程序。除了识别您正在通信的系统之外，Erlang 在一般使用中不区分系统的本地或远程特征。

为了开始使用分布式编程，首先您需要启动 Erlang，为 Erlang 的每个实例提供一个惟一名称。这样的名称将在识别过程中使用，使您能够向 Erlang 的命名实例发送消息。为了在使用 Erlang 时通过命令行设置名称，您可以使用 sname 命令行选项（请参见清单 3）。

清单 3. 使用 sname 命令行选项

$ erl -sname one
Erlang R13B04 (erts-5.7.5) [source] [64-bit] [rq:1] [async-threads:0]

Eshell V5.7.5  (abort with ^G)
(one@mammoth)1>

请注意提示符如何更改为提供名称和主机名，这是节点的惟一标识符，可在 Erlang 中用于识别节点以及在节点间通信。

如果启动 Erlang shell 的另外一个实例，可设置另外一个不同的名称，如清单 4 所示。

清单 4. 设置不同的名称

$ erl -sname two 
Erlang R14B (erts-5.8.1) [source] [smp:8:8] [rq:8] [async-threads:0] [hipe] 
[kernel-poll:false]

Eshell V5.8.1  (abort with ^G)
(two@mammoth)1>

在两个节点都运行后，即可使用 net_adm:ping() 测试一个节点能否与另一个节点通信（请参见清单 5）。

清单 5. 使用 `net_adm:ping()` 测试一个节点能否与另一个节点通信

(one@mammoth)3> net_adm:ping('two@mammoth').
pong

这表明实例一可以与实例二通信。

为了在两个进程之间发送消息，您可使用修改后的消息传递操作符，在其中包含节点名称以及接收方的进程 id。例如，如果一个进程使用名称 basic 注册，您可以使用清单 5 中的代码发送消息。可以将此代码键入之前创建的第一个 Erlang 实例的 shell 中： { basic, 'two@mammoth'} ! { self(), "message" }。

在第二个主机上，如果您将当前进程（也就是 shell）注册为 “basic”，随后检索可输出消息数据的消息。则将需要在实例一中发送消息之前注册当前进程（请参见清单 6）。

清单 6. 注册当前进程

(two@mammoth)1> register(basic,self()).
true

接下来创建 receive 语句以输出消息（请参见清单 7）。

清单 7. 创建 `receive` 语句来输出消息

(two@mammoth)2> receive                             
(two@mammoth)2> {From,Message} -> io:format(Message ++ "~n")
(two@mammoth)2> end.
something
ok

您已经成功地在 Erlang 的两个实例间发送了消息。它们完全可能处于世界的两端，而不是相同的机器上。在两台机器之间发送消息时，发送和接收任意类型的数据都变得极为简单，只需了解进程 ID 和节点名称即可。

对于更熟悉的远程过程调用，Erlang 还支持 rpc:call() 函数： rpc:call(Node, Module, Function, Arguments)。

这将调用远程节点，使用所提供的参数执行特定模块和函数，并将结果返回给调用方。rpc 模块包含允许同步、异步和阻塞调用的扩展。这是一个直接函数调用，若多个客户端同时运行此调用，则会发生并行问题，与消息传递模型相比绝非理想方法，但具体选择将取决于您的应用程序。

使用 MochiWeb

MochiWeb 是一个完整的 HTTP Web 体系，构建于 Erlang 之上。它利用了本文所述的许多 Erlang 特性，包括使用消息传递和进程来提供高性能与高级并行性。MochiWeb 利用进程系统支持并行性，利用消息来帮助处理请求和收集结果。

MochiWeb 本身结合了代码和一套脚本，使您能够迅速创建一个基本框架，您可在其中构建和扩展自己的应用程序。在最后这一部分内容中，我们将介绍如何利用 MochiWeb、设置新的 Web 服务器应用程序，以及如何将其扩展为支持您自己的应用程序。

获得 MochiWeb 的最便捷的方法就是从 GitHub 获得源代码。为此，您可以使用 git 命令，也可使用 GitHub 网站中的可下载包（请参见参考资料）。

为了使用 git 获得源代码，请使用： $ git clone https://github.com/mochi/mochiweb.git。

这将在您的当前目录中创建一个名为 mochiweb 的目录。为了使用 MochiWeb，您需要生成源代码。这将准备好 MochiWeb 以便您创建新的 MochiWeb 应用程序。

为此，首先在 mochiweb 目录中运行 make 命令，如清单 8 所示。

清单 8. 生成资源

$ cd mochiweb $ make
==> mochiweb (get-deps)
==> mochiweb (compile)
Compiled src/mochiweb_sup.erl
Compiled src/mochifmt.erl
Compiled src/mochiweb_charref.erl
Compiled src/mochiweb_request_tests.erl
Compiled src/mochifmt_records.erl
Compiled src/mochiweb_socket.erl
Compiled src/mochiweb_app.erl
Compiled src/mochiweb_io.erl
Compiled src/mochifmt_std.erl
Compiled src/mochiglobal.erl
Compiled src/mochiweb_socket_server.erl
Compiled src/mochijson.erl
Compiled src/mochihex.erl
Compiled src/mochiweb_html.erl
Compiled src/mochiweb_multipart.erl
Compiled src/mochilogfile2.erl
Compiled src/mochiweb_cover.erl
Compiled src/mochiweb_util.erl
Compiled src/mochitemp.erl
Compiled src/reloader.erl
Compiled src/mochinum.erl
Compiled src/mochiweb_headers.erl
Compiled src/mochiweb_skel.erl
Compiled src/mochiutf8.erl
Compiled src/mochiweb_echo.erl
Compiled src/mochiweb_acceptor.erl
Compiled src/mochiweb_http.erl
Compiled src/mochijson2.erl
Compiled src/mochiweb_cookies.erl
Compiled src/mochiweb.erl
Compiled src/mochiweb_mime.erl
Compiled src/mochilists.erl
Compiled src/mochiweb_response.erl
Compiled src/mochiweb_request.erl

这就完成了 mochiweb 源代码的编译。为了创建一个示例应用程序框架，以便用于构建我们自己的 Web 服务器，您将再一次使用 make 来生成新项目目录。PROJECT 将成为项目和目录名称，PREFIX 将成为在其中创建新 PROJECT 目录的目录名称。例如，要创建一个名为 mywebserver 的项目： $ make app PROJECT=mywebserver PREFIX=../。

上面的代码行将在父目录内创建一个新的 MochiWeb 应用程序（也就是说，与 mochiweb 相同的级别）。

新创建的目录是一个基本 Web 服务器，它将默认侦听 8080 端口（在所有接口上）。要生成应用程序，请再次运行 make，确保编译 MochiWeb 组件和各应用程序：

$ cd ../mywebserver
$ make

最后，运行 start-dev.sh script 来运行基本应用程序。这将生成大量输出，所有这些输出都是 “进度报告”，表示创建用于处理 Web 服务器的各进程。如果输出中未报告任何错误，则 Web 服务器即可正常运行（请参见清单 9）。

清单 9. Web 服务器正常运行

Erlang R13B04 (erts-5.7.5) [source] [64-bit] [rq:1] [async-threads:0]

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
          supervisor: {local,sasl_safe_sup}
             started: [{pid,<0.42.0>},
                       {name,alarm_handler},
                       {mfa,{alarm_handler,start_link,[]}},
                       {restart_type,permanent},
                       {shutdown,2000},
                       {child_type,worker}]

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
          supervisor: {local,sasl_safe_sup}
             started: [{pid,<0.43.0>},
                       {name,overload},
                       {mfa,{overload,start_link,[]}},
                       {restart_type,permanent},
                       {shutdown,2000},
                       {child_type,worker}]

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
          supervisor: {local,sasl_sup}
             started: [{pid,<0.41.0>},
                       {name,sasl_safe_sup},
                       {mfa,
                           {supervisor,start_link,
                               [{local,sasl_safe_sup},sasl,safe]}},
                       {restart_type,permanent},
                       {shutdown,infinity},
                       {child_type,supervisor}]

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
          supervisor: {local,sasl_sup}
             started: [{pid,<0.44.0>},
                       {name,release_handler},
                       {mfa,{release_handler,start_link,[]}},
                       {restart_type,permanent},
                       {shutdown,2000},
                       {child_type,worker}]

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
         application: sasl
          started_at: mywebserver_dev@localhost
Eshell V5.7.5  (abort with ^G)
(mywebserver_dev@localhost)1> ** Found 0 name clashes in code paths 

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
          supervisor: {local,crypto_sup}
             started: [{pid,<0.54.0>},
                       {name,crypto_server},
                       {mfa,{crypto_server,start_link,[]}},
                       {restart_type,permanent},
                       {shutdown,2000},
                       {child_type,worker}]

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
         application: crypto
          started_at: mywebserver_dev@localhost
** Found 0 name clashes in code paths 

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
          supervisor: {local,mywebserver_sup}
             started: [{pid,<0.59.0>},
                       {name,mywebserver_web},
                       {mfa,
                           {mywebserver_web,start,
                               [[{ip,{0,0,0,0}},
                                 {port,8080},
                                 {docroot,
                                     "/root/mybase/mywebserver/priv/www"}]]}},
                       {restart_type,permanent},
                       {shutdown,5000},
                       {child_type,worker}]

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
         application: mywebserver
          started_at: mywebserver_dev@localhost

=PROGRESS REPORT==== 7-Apr-2011::11:40:36 ===
          supervisor: {local,kernel_safe_sup}
             started: [{pid,<0.77.0>},
                       {name,timer_server},
                       {mfa,{timer,start_link,[]}},
                       {restart_type,permanent},
                       {shutdown,1000},
                       {child_type,worker}]

您可以打开 Web 浏览器，尝试访问新的 Web 服务器。如果该 Web 服务器处于相同的机器上，您可打开 http://localhost:8080/。如果一切正常工作，您应看到一个页面，标题为 “It Worked”，其中包含的消息为 “webserver running.”。

如果您希望修改新服务器，可以在应用程序目录中编辑 src/mywebserver_web.erl 文件。此文件中包含运行和支持 Web 服务的核心代码。

进程的核心是 loop() 函数，MochiWeb 主系统每次接收到一条请求时都会调用此函数。此函数提供两个参数，请求结构（其中包含请求类型、路径和任意主体数据）以及 DocRoot。后者必不可少，因为服务器默认将从指定文档根下的文件系统中提供所请求的文件。

请求的处理分为两个阶段，首先使用 case 语句提取请求类型（GET、POST 等）。随后，使用第二条 case 语句来识别请求的路径。

您可以使用 Erlang 中的模式匹配，因此一端的路径可触发特定响应。举例来说，可以修改代码，使得对于服务器上 /hello 路径的访问返回短语 “Hello world”，如清单 10 所示。

清单 10. Erlang 中的模式匹配

loop(Req, DocRoot) ->
    "/" ++ Path = Req:get(path),
    try
        case Req:get(method) of
            Method when Method =:= 'GET'; Method =:= 'HEAD' ->
                case Path of
                    "congrat" ->
                        Req:ok({"text/html", [],["<h1>Congratulation
</h1>"]});
                    "hello" ->
                        Req:ok({"text/plain",[],["Hello world"]});
                    _ ->
                        Req:serve_file(Path, DocRoot)
                end;
            'POST' ->
                case Path of
                    _ ->
                        Req:not_found()
                end;
            _ ->
                Req:respond({501, [], []})
        end
    catch
        Type:What ->
            Report = ["web request failed",
                      {path, Path},
                      {type, Type}, {what, What},
                      {trace, erlang:get_stacktrace()}],
            error_logger:error_report(Report),
            %% NOTE: mustache templates need \ because they are not awesome.
            Req:respond({500, [{"Content-Type", "text/plain"}],
                         "request failed, sorry\n"})
    end.

编辑好文件之后，请确保运行 make，重新生成应用程序，随后使用 start-dev.sh 脚本重新启动应用程序。

现在，如果使用 http://localhost:8080/hello 访问您的 Web 服务器的 URL，您应得到 hello world 消息。

尽管这只是一个基本的示例，但您能看到，通过寻找 POST 或 PUT 请求、处理文档正文、随后存储信息，基本 REST 服务支持等新功能的添加即可轻松实现。使用衍生进程和消息传递，您就可以对来自服务器的请求进行排队，以便存储、更新和检索信息。

结束语

Erlang 曾经用于电话交换机环境中，这也就意味着该语言的核心功能是在与其他大多数语言完全不同的环境中开发的。运行和创建多个进程来处理大量并行操作（例如，电话呼叫）的问题也内置于此语言之中。

通过利用内置的消息传递系统，通过一种无破坏性、也不需要复杂信号量系统在进程间共享信息的方法，创建新进程并在进程间通信的过程即可得到简化。由于消息传递是顺序的，因此各进程间的通信将易于处理。此外，消息系统跨 Erlang 实例、通过网络操作，这使得跨机器通信更为简单直观。

MochiWeb 将大多数此类功能结合在一起，提供了一种高性能、高可伸缩的 Web 服务器解决方案，也可轻松扩展和延伸为支持额外的功能，所需工作量极少。

posted @ 2014-03-03 21:02 高盛阅读(1853) 评论(0) 编辑收藏举报

刷新页面返回顶部