具有多个客户端外壳的 Erlang - 生成的进程挂在“io”模块中

Question

通过 Joe 的书，卡在第 12 章练习 1。该练习要求编写一个函数 start(AnAtom,Fun)，它将 AnAtom 注册为生成（有趣）。我决定尝试一些看似更简单的方法 - 采用本章完成的“area_server”模块，并修改它的 start/0 函数，如下所示：

start() ->
    Pid = spawn(ex1, loop, []),
    io:format("Spawned ~p~n",[Pid]),
    register(area, Pid).

所以代替执行任意 Fun 的进程，我正在注册“循环”，它是 area_server 模块中的一个函数，完成所有工作：

loop() ->
    receive
        {From, {rectangle, Width, Ht}} ->
            io:format("Computing for rectangle...~n"),
            From ! {self(), Width*Ht},
            loop();
        {From, {square, Side}} ->
            io:format("Computing for square...~n"),
            From ! {self(), Side*Side},
            loop();
        {From, Other} ->
            io:format("lolwut?~n"),
            From ! {self(), {error, Other}},
            loop()
    end.

它似乎工作得很好：

1> c("ex1.erl").
{ok,ex1}
2> ex1:start(). 
Spawned <0.68.0>
true
3> 
3> area ! {self(), hi}.
lolwut?
{<0.61.0>,hi}
4> flush().
Shell got {<0.68.0>,{error,hi}}
ok
5> area ! {self(), {square, 7}}.
Computing for square...
{<0.61.0>,{square,7}}
6> flush().
Shell got {<0.68.0>,49}
ok

当我尝试测试多个进程是否可以与注册的“服务器”通信时，事情变得很糟糕。 (CTRL-G, s, c 2)

我在一个新的 shell 中，与第一个 shell 一起运行 - 但是当我从这个新 shell 向我的“区域”注册进程发送消息时，会发生一些令人讨厌的事情 - 当查询 process_info(whereis(area)), process从此状态移动：

 {current_function,{ex1,loop,0}},
 {initial_call,{ex1,loop,0}},

到这个：

 {current_function,{io,execute_request,2}},
 {initial_call,{ex1,loop,0}},

当消息队列开始增长时，消息没有得到处理。挂在模块io中，呵呵！ io操作被阻止了？显然，该过程从我的 ex1:loop/0 移动到 io:execute_request/2 （不管是什么）...是我的愚蠢打印导致问题吗？

Answer 1

您的进程正在执行您期望的操作除了在什么时候处理谁可以控制 STDOUT。是的，这可能会导致 shell 出现奇怪的行为。

所以让我们尝试这样的事情没有任何暗示去STDOUT的IO命令，看看会发生什么。下面是一个 shell 会话，我在其中定义了一个循环来累积消息，直到我要求它向我发送它所累积的消息。我们可以从这个例子中看到（它不会挂断谁被允许与单个输出资源对话）进程的行为符合预期。

需要注意的一点是，您不需要多个 shell 来与多个进程通信或从多个进程通信。

注意shell中flush/0的返回值——这是一个特殊的shell命令，将shell的邮箱转储到STDOUT。

Eshell V9.0  (abort with ^G)
1> Loop = 
1>   fun L(History) ->
1>     receive
1>       halt ->
1>         exit(normal);
1>       {Sender, history} ->
1>         Sender ! History,
1>         L([]);
1>       Message ->
1>         NewHistory = [Message | History],
1>         L(NewHistory)
1>     end
1>   end.
#Fun<erl_eval.30.87737649>
2> {Pid1, Ref1} = spawn_monitor(fun() -> Loop([]) end).
{<0.64.0>,#Ref<0.1663562856.2369257474.102541>}
3> {Pid2, Ref2} = spawn_monitor(fun() -> Loop([]) end).
{<0.66.0>,#Ref<0.1663562856.2369257474.102546>}
4> Pid1 ! "blah".
"blah"
5> Pid1 ! "blee".
"blee"
6> Pid1 ! {self(), history}.
{<0.61.0>,history}
7> flush().
Shell got ["blee","blah"]
ok
8> Pid1 ! "Message from shell 1". 
"Message from shell 1"
9> Pid2 ! "Message from shell 1".
"Message from shell 1"
10> 
User switch command
 --> s
 --> j
   1  {shell,start,[init]}
   2* {shell,start,[]}
 --> c 2
Eshell V9.0  (abort with ^G)
1> Shell1_Pid1 = pid(0,64,0).
<0.64.0>
2> Shell1_Pid2 = pid(0,66,0).
<0.66.0>
3> Shell1_Pid1 ! "Message from shell 2".
"Message from shell 2"
4> Shell1_Pid2 ! "Another message from shell 2".
"Another message from shell 2"
5> Shell1_Pid1 ! {self(), history}.
{<0.77.0>,history}
6> flush().
Shell got ["Message from shell 2","Message from shell 1"]
ok
7> 
User switch command
 --> c 1

11> Pid2 ! {self(), history}.
{<0.61.0>,history}
12> flush().
Shell got ["Another message from shell 2","Message from shell 1"]
ok