Concurrency Erlang并发理解

最近我一直在试图理解Erlang中的并发服务器。考虑下面的向服务器发出请求的代码。取决于 特定的执行顺序，3个进程可能会打印出不同的值。每个过程的顺序是什么，最高值和最低值是什么

test() ->
    Server = start(),
    spawn(fun() ->
                  incr(Server),
                  io:format("Child 1 read ~p~n", [read(Server)]) end),
    incr(Server),
    spawn(fun() ->
                  incr(Server),
                  io:format("Child 2 read ~p~n", [read(Server)]) end),
    io:format("Parent read ~p~n", [read(Server)]).

代码针对以下服务器运行：

-module(p4).
-export([start/0, init/0, read/1, incr/1, reset/1]).

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

loop(N) ->
    receive
        {read, Pid} ->
            Pid ! {value, self(), N},
            loop(N);
        {incr, Pid} ->
            Pid ! {incr_reply, self()},
            loop(N+1);
        {reset, Pid} ->
            Pid ! {reset_reply, self()},
            loop(0)
    end.

read(Serv) ->
    Serv ! {read, self()},
    receive {value, Serv, N} -> N end.
incr(Serv) ->
    Serv ! {incr, self()},
    receive {incr_reply, Serv} -> ok end.
reset(Serv) ->
    Serv ! {reset, self()},
    receive {reset_reply, Serv} -> ok end.

• 父级：最低=1最高=3
• 孩子1：最低=1最高=3
• 儿童2：最低=1最高=2

我不完全确定订单，但我想可能是：

• Child1可以阅读1、2和3
• 家长可以阅读1、2和3
• 儿童2可以阅读1和2

---

对于最低值、最高值和订单，这是否正确？

循环中的初始值为0。服务器的增量操作会在执行增量之前回复调用方，但这并不重要，因为在发送该回复和实际增量之间不会处理任何消息。每个已读消息都会产生一个回复，其中包含在它之前到达的所有增量消息的效果。由于保证了从一个进程到另一个进程的消息顺序，因此任何增加读取量的进程都保证至少读取自己的增量。服务器的读取操作只是用当前循环值进行响应。重置操作未使用

Child1递增，然后读取。它最初与Parent并发运行，随后又与Child2并发运行，两者都会递增。因此，它可以仅从自己的增量中读取1，从自己的增量和其父增量中读取2，或者如果它的读取也从Child2中读取增量，则可以读取3

Child2也会递增，然后读取，但直到父级已经递增之后才会开始。因此，它可以读取的最小值是2，并且由于它与Child1同时运行，因此它也可以读取3

---

父级递增，然后读取，因此它可以读取的最小值为1。它的读取与Child1和Child2同时运行，因此如果它的读取发生在它们的增量之前，它会看到1。如果它的读取选择了其中一个子增量，它也可以读取2；如果它的读取选择了两个子增量，它可以读取3。

可能与它的相似概念重复，但我只想知道这次我是否正确。试图理解输出的顺序。只是一点补充，所有三个输出都可以以任何顺序出现在控制台中，因为它们是从三个独立进程发送的消息。