Erlang 服务器请求顺序

Question

我正在尝试理解 erlang 中的请求顺序，但我似乎无法很好地掌握它。下面是示例代码：

test() ->
    Server  = start(),
    spawn(fun() -> write(Server, 2),
                   io:format(”Child 1 read ~p~n”, [read(Server)]) end),
    write(Server, 3),
    write2(Server, 5),
    spawn(fun() -> write2(Server, 1),
                   io:format(”Child 2 read  ~p~n”, [read(Server)]) end),
    io:format(”Parent read ~p~n”, [read(Server)]).

这是服务器：

start() ->
    spawn(fun() -> init() end).

init() -> loop(0).

loop(N) ->
    receive
        {read, Pid} ->
            Pid ! {value, self(), N},
            loop(N);
        {write, Pid, M} ->
            Pid ! {write_reply, self()},
            loop(M);
        {write2, _Pid, M} -> loop(M)
    end.

read(Serv) ->
    Serv ! {read, self()},
    receive {value, Serv, N} -> N end.

write(Serv, N) ->
    Serv ! {write, self(), N},
    receive {write_reply, Serv} -> ok end.

write2(Serv, N) ->
    Serv ! {write2, self(), N},
    ok.

我知道test/0 中创建的三个不同进程可以打印不同的值，但我试图找出Parent、Child1 和@ 可以打印的最低和最高值987654326@ 进程。答案是：

• Parent：最低1，最高5
• Child1：最低1，最高5
• Child2：最低1，最高2

谁能解释一下？

Answer 1

请记住，Erlang 只保证从一个进程到另一个进程的消息顺序。如果进程 A 依次向进程 B 发送消息 1 和消息 2，则 B 将按此顺序接收它们。但是，如果多个并发进程正在发送消息，Erlang 不会保证到达 B 的消息的特定顺序。在此示例中，Parent、Child1 和 Child2 都同时运行，并且都同时向Server 发送消息。

Parent 进程执行以下顺序步骤：

1. 产生Server 进程。这最终将Server循环中的初始值设置为0。
2. 生成Child1。这最终将值2 写入Server，然后从Server 读取并打印结果。
3. 使用write/2 将值3 发送到Server。 loop/1 函数中的 write 案例首先回复调用者，然后为下一次迭代安装值 3。
4. 使用write2/2 将5 发送到Server。 write2/2 函数只是向Server 发送消息，并不等待回复。 loop/1 函数中的 write2 案例只是为其下一次迭代安装值 5。
5. 生成Child2，最终使用值1 调用write2/2，然后读取Server 并打印结果。
6. 读取Server 并打印结果。

对于Parent，步骤3 将值3 发送到Server，因此就Parent 而言，Server 现在具有值3。在步骤 4 中，Parent 调用 write2/2 将 5 发送到服务器，并且该消息必须在步骤 3 中发送的消息之后的某个时间到达 Server。在步骤 6 中，Parent 执行读取，但是我们所知道的是，此消息必须在第 4 步中写入消息之后到达Server。此消息排序意味着Parent 可以看到的最高值是5。

Parent 可以看到的最低值是1，因为如果Child2 在Parent 写入消息5 之后但在最终Parent 之前将其写入消息1 发送到Server阅读消息，然后Parent 将看到1。

对于Child1，它可以看到的最高值是5，因为它与Parent 并发运行，并且Parent 发送的两条消息可能在其写入消息2 之前到达Server。 Child1 可以看到的最低值是1，因为1 的Child2 写入消息可以在Child1 读取消息之前到达。

对于Child2，它可以看到的最低值是它自己写的1。它可以看到的最高值是来自Child1 写入的2，因为3 和5 的Parent 写入发生在生成Child2 之前，因此Child1 是唯一同时写入的进程并且所以只有它有机会在Child2 写入和读取消息之间交错写入消息。