Erlang笔记 -- 并发编程

Erlang的并发是基于进程（process）的。进程是一些独立的小型虚拟机，可以执行Erlang函数。
在Erlang里，进程隶属于编程语言，而非操作系统。这就意味着Erlang的进程在任何操作系统上都会具有相同的逻辑行为，这样，就能编写可移植的并发代码，让它在任何支持Erlang的操作系统上运行。
在Erlang里：

1. 创建和销毁进程是非常快速的；
2. 在进程间发送消息是非常快速的；
3. 进程在所有操作系统上都具有相同的行为方式；
4. 可以拥有大量进程；
5. 进程不共享任何内存，是完全独立的；
6. 进程唯一的交互方式就是消息传递。

1. 基本并发函数

• Pid = spawn(Mod, Func, Args)
  创建一个新的并发进程来执行apply(Mod, Func, Args)。这个新进程和调用进程并列运行。spawn返回一个Pid（process identifier的简称，即进程标识符）。可以用Pid来给此进程发送消息。请注意，元数为length(Args)的Func函数必须从Mod模块导出。
  当一个新进程被创建后，会使用最新版的代码定义模块。
• Pid = spawn(Fun)
  创建一个新的并发进程来执行Fun()。这种形式的spawn总是使用被执行fun的当前值，而且这个fun无需从模块里导出。
• Pid ! Msg
  向标识符为Pid的进程发送消息Message。消息发送是异步的。!被称为发送操作符。
  Pid ! M的结果被定义为M。Pid1 ! Pid2 !...! Msg的意思是把消息Msg发送给Pid1、Pid2等所有进程。
• receive...end
  接收发送给某个进程的消息。它的语法如下：

receive
    Pattern1 [when Guard1] ->
        Expressions1;
    Pattern2 [when Guard2] ->
        Expressions2;
    ...
end

当某个消息到达进程后，系统会尝试将它与Pattern1（以及可选的关卡Guard1）匹配，如果成功就执行Expressions1。如果第一个模式不匹配，就会尝试Pattern2，以此类推。如果没有匹配的模式，消息就会被保存起来供以后处理，进程则会开始等待下一条消息。

当spawn命令被执行时，系统会创建一个新的进程。每个进程都带有一个邮箱，这个邮箱是和进程同步创建的。给某个进程发送消息后，消息会被放入该进程的邮箱。只有当程序执行一条接收语句时才会读取邮箱。
定义area/1函数的代码如下：

%% geometry.erl
area({rectangle, Width, Heigth}) -> Width * Heigth;
area({square, Side}) -> Side * Side.

现在把这个函数改写成一个进程。为此，我们从area函数的参数里取了两个模式，然后把它们重置为接收语句里的模式。

%% area_server0.erl
-module(area_server0).
-export([loop/0]).

loop() ->
    receive
        {rectangle, Width, Heigth} ->
            io:format("Area of rectangle is ~p~n", [Width*Heigth]),
            loop();
        {square, Side} ->
            io:format("Area of square is ~p~n", [Side*Side]),
            loop()
    end.

1> Pid = spawn(area_server0, loop, []).
<0.62.0>
2> Pid ! {rectangle, 2, 3}.
Area of rectangle is 6
{rectangle,2,3}
3> Pid ! {square, 2}.
Area of square is 4
{square,2}

我们在第1行里创建了一个新的并行进程。spawn(area_server, loop, [])会创建一个执行area_server:loop()的并行进程，然后返回Pid，也就是打印出来的<0.62.0>。
在第2行里向这个进程发送了一个消息。这个消息匹配loop/0接收语句里的第一个模式：

loop() ->
    receive
        {rectangle, Width, Heigth} ->
            io:format("Area of rectangle is ~p~n", [Width*Heigth]),
            loop();
     ...

收到消息之后，这个进程打印出矩形的面积。最后，shell打印出{rectangle, 6, 10}，这是因为Pid ! Msg的值被定义为Msg。

2. 客户端 - 服务器介绍

客户端-服务器架构是Erlang的中心。
客户端-服务器架构里的客户端和服务器是不同的进程，它们之间的通信使用普通的Erlang消息传递机制。客户端和服务器可以运行在同一台机器上，也可以运行在不同的机器上。
客户端和服务器这两个词是指这两种进程所扮演的角色：客户端总是通过向服务器发送一个请求来发起计算。服务器计算后生成回复，然后发送一个响应给客户端。
下面来编写我们的第一个客户端-服务器应用程序。

%% area_server_final.erl
-module(area_server_final).
-export([start/0, area/2, loop/0]).

start() -> spawn(area_server_final, loop, []).

area(Pid, What) ->
	rpc(Pid, What).
rpc(Pid, Request) ->
	Pid ! {self(), Request},
	receive
		{Pid, Response} ->
			Response
	end.
loop() ->
    receive
        {From, {rectangle, Width, Heigth}} ->
            From ! {self(), Width*Heigth},
            loop();
        {From, {square, Side}} ->
            From ! {self(), Side*Side},
            loop();
		{From, Other} ->
			From ! {self(), {error, Other}},
            loop()
    end.

我们调用函数start/0和area/2来运行它。

1> Pid = area_server_final:start().
<0.75.0>
2> area_server_final:area(Pid, {rectangle, 2,3}).
6
3> area_server_final:area(Pid, {square, 2}).
4

3. 带超时的接收

有时候一条接收语句会因为消息迟迟不来而一直等下去。发生这种情况的原因有很多，比如程序里可能有一处逻辑错误，或者准备发送消息的进程在消息发出前就崩溃了。要避免这个问题，可以给接收语句增加一个超时设置，设定进程等待接收消息的最长时间。它的语法如下：

receive
    Pattern1 [when Guard1] ->
        Expressions1;
    Pattern2 [when Guard2] ->
        Expressions2;
    ...
after Time ->
    Expressions
end.

如果在进入接收表达式的Time毫秒后还没有收到匹配的消息，进程就会停止等待消息，转而执行Expressions。

1. 可以编写一个只有超时部分的receive。通过这种方法，我们可以定义一个sleep(T)函数，它会让当前的进程挂起T毫秒。

sleep(T) ->
    receive
    after T ->
        true
    end.

2. 超时值为0会让超时的主体部分立即发生，但在这之前，系统会尝试对邮箱里的消息进行匹配。我们可以用它来定义一个flush_buffer函数，它会清空进程邮箱里的所有消息。

flush_buffer() ->
    receive
        _Any ->
            flush_buffer()
    after 0 ->
        true
    end.

如果没有超时子句，flush_buffer就会在邮箱为空时永远挂起且不返回。我们还可以使用零超时来实现某种形式的“优先接收”，就像下面这样：

priority_receive() ->
    receive
        {alarm, X} ->
            {alarm, X}
    after 0 ->
        receive
            Any ->
                Any
        end
    end.

如果邮箱里不存在匹配{alarm, X}的消息，priority_receive就会接收邮箱里的第一个消息。如果没有任何消息，它就会在最里面的接收语句处挂起，并返回它收到的第一个消息。如果存在匹配{alarm, X}的消息，这个消息就会被立即返回。请记住，只有当邮箱里的所有条目都进行过模式匹配后，才会检查after部分。
如果没有after 0语句，警告（alarm）消息就不会被首先匹配。

3. 如果接收语句里的超时值是原子infinity（无穷大），就永远不会触发超时。这对那些在接收语句之外计算超时值的程序可能很有用。有时候计算的结果是返回一个实际的超时值，其他的时候则是让接收语句永远等待下去。

4. 可以用接收超时来实现一个简单的定时器。
   函数stimer:start(Time, Fun)会在Time毫秒之后执行Fun（一个不带参数的函数）。它返回一个句柄（是一个PID），可以在需要时用来关闭定时器。

%% stimer.erl
-module(stimer).
-export([start/2, cancel/1]).

start(Time, Fun) -> spawn(fun() -> timer(Time, Fun) end).
cancel(Pid) -> Pid ! cancel.
timer(Time, Fun) ->
	receive
        cancel ->
            void
    after Time ->
        Fun()
    end.

4. 选择性接收

基本函数receive用来从进程邮箱里提取消息，但它所做的不仅仅是简单的模式匹配。它还会把未匹配的消息加入队列供以后处理，并管理超时。下面这个语句：

receive
    Pattern1 [when Guard1] ->
        Expressions1;
    Pattern2 [when Guard2] ->
        Expressions2;
    ...
after Time ->
    ExpressionsTimeout
end.

它的工作方式如下。

1. 进入receive语句时会启动一个定时器（但只有当表达式包含after部分时才会如此）。
2. 取出邮箱里的第一个消息，尝试将它与Pattern1、Pattern2等模式匹配。如果匹配成功，系统就会从邮箱中移除这个消息，并执行模式后面的表达式。
3. 如果receive语句里的所有模式都不匹配邮箱的第一个消息，系统就会从邮箱中移除这个消息并把它放入一个“保存队列”，然后继续尝试邮箱里的第二个消息。这一过程会不断重复，直到发现匹配的消息或者邮箱里的所有消息都被检查过了为止。
4. 如果邮箱里的所有消息都不匹配，进程就会被挂起并重新调度，直到新的消息进入邮箱才会继续执行。新消息到达后，保存队列里的消息不会重新匹配，只有新消息才会进行匹配。
5. 一旦某个消息匹配成功，保存队列里的所有消息就会按照到达进程的顺序重新进入邮箱。如果设置了定时器，就会清除它。
6. 如果定时器在我们等待消息时到期了，系统就会执行表达式ExpressionsTimeout，并把所有保存的消息按照它们到达进程的顺序重新放回邮箱。

5. 注册进程

如果想给一个进程发送消息，就需要知道它的PID，但是当进程创建时，只有父进程才知道它的PID。系统里没有其他进程知道它的存在。这通常很不方便，因为你必须把PID发送给系统里所有想要和它通信的进程。另一方面，这也很安全。如果不透露某个进程的PID，其他进程就无法以任何方式与其交互。
Erlang有一种公布进程标识符的方法，它让系统里的任何进程都能与该进程通信。这样的进程被称为注册进程（registered process）。管理注册进程的内置函数有四个。

• register(AnAtom, Pid)
  用AnAtom（一个原子）作为名称来注册进程Pid。如果AnAtom已被用于注册某个进程，这次注册就会失败。

• unregister(AnAtom)
  移除与AnAtom关联的所有注册信息。
  注意 如果某个注册进程崩溃了，就会自动取消注册。

• whereis(AnAtom) -> Pid | undefined
  检查AnAtom是否已被注册。如果是就返回进程标识符Pid，如果没有找到与AnAtom关联的进程就返回原子undefined。

• register() -> [AnAtom::atom()]
  返回一个包含系统里所有注册进程的列表。
  可以用register来制作一个模拟时钟的注册进程。

%% clock.erl
-module(clock).
-export([start/2, stop/0]).

start(Time, Fun) ->
	register(clock, spawn(fun() -> tick(Time, Fun) end)).
stop() -> clock ! stop.
tick(Time, Fun) ->
	receive
		stop ->
			void
	after Time ->
		Fun(),
		tick(Time, Fun)
	end.

这个时钟会不断滴答作响，直到你停止它。

1> clock:start(5000, fun() -> io:format("Tick ~p~n", [erlang:now()]) end).
true
2> Tick {1602,667147,205065}
2> Tick {1602,667152,221109}
2> Tick {1602,667157,237231}
2> Tick {1602,667162,252403}
2> Tick {1602,667167,268574}
2> clock:stop().
stop

6. 尾递归

%% area_server_final.erl
loop() ->
    receive
        {From, {rectangle, Width, Heigth}} ->
            From ! {self(), Width*Heigth},
            loop();
        {From, {square, Side}} ->
            From ! {self(), Side*Side},
            loop();
		{From, Other} ->
			From ! {self(), {error, Other}},
            loop()
    end.

如果你仔细观察，就会发现每当我们收到消息时就会处理它并立即再次调用loop()。这一过程被称为尾递归（tail-recursive）。可以对一个尾递归的函数进行特别编译，把语句序列里的最后一次函数调用替换成跳至被调用函数的开头。这就意味着尾递归的函数无需消耗栈空间也能一直循环下去。
假设编写了以下（不正确的）代码：

loop() ->
    receive
        {From, {rectangle, Width, Heigth}} ->
            From ! {self(), Width*Heigth},
            loop(),
	    someOtherFunc();
        {From, {square, Side}} ->
            From ! {self(), Side*Side},
            loop();
	    ...
    end.

我们在第5行里调用了loop()，但是编译器必然推断出“当我调用loop()后必须返回这里，因为我得调用第6行里的someOtherFunc()”。于是它把someOtherFunc的地址推入栈，然后跳到loop的开头。这么做的问题在于loop()是永不返回的，它会一直循环下去。所以，每次经过第5行，就会有一个返回地址被推入控制栈，最终系统的空间会消耗殆尽。
避免这个问题的方法很简单，如果你编写的函数F是永不返回的（就像loop()一样），就要确保在调用F之后不再调用其他任何东西，并且别把F用在列表或元组构造器里。

7. 用MFA或Fun进行分裂

用显式的模块、函数名和参数列表（称为MFA）来分裂一个函数是确保运行进程能够正确升级为新版模块代码（即使用中被再次编译）的恰当方式。动态代码升级机制不适用于fun的分裂，只能用于带有显式名称的MFA上。

8. 一个并发程序模板

编写并发程序，可以从下面的代码起步：

-module(ctemplate).
-compile(export_all).
start() ->
    spawn(?MODULE, loop, []).
rpc(Pid, Request) ->
    Pid ! {self(), Request},
    receive
        {Pid, Response} ->
            Response
    end.
loop(X) ->
    receive
        Any ->
            io:format("Received:~p~n",[Any]),
            loop(X)
    end. 

注：本博客为通过《Erlang程序设计 第二版》学习Erlang时所做的笔记。学习更详细的内容，建议直接阅读《Erlang程序设计 第二版》。