我如何从Erlang中产生的过程中获得返回值？

如何解决我如何从Erlang中产生的过程中获得返回值？

我有以下代码：

-module(a).
-compile(export_all).

say(2,0) ->
    [1,2];

say(A,B) ->
    say(A-1,B-1).

loop(0) ->
    io:format("");

loop(Times) ->
    L = spawn(a,say,[4,2]),io:fwrite( "L is ~w  ~n",[L] ),loop(Times-1).

run() ->
    loop(4).

我希望每次函数“ say”完成时在L中都有列表[1,2]。但是，由于由于使用了spawn而返回了进程的pid而不是函数说的列表，因此我得到以下输出：

L is <0.113.0>  
L is <0.114.0>  
L is <0.115.0>  
L is <0.116.0>  

我想要的是

L is [1,2]
L is [1,2]

我该如何实现？

解决方法

您需要为此使用消息（或信号），因为代码在单独的进程中运行。

在这种情况下，我喜欢使用spawn_monitor：

1> {Pid,MonitorReference} = spawn_monitor(fun() -> timer:sleep(10000),exit({ok,[1,2]}) end),1> receive {'DOWN',MonitorReference,process,Pid,{ok,Result}} -> Result end.

请记住，您可以同时receive处理多封邮件，也可以按顺序接收（在邮箱中保留乱序的邮件）。因此，您可以生成多个线程并等待所有线程完成，以收集结果：

work(Workload) ->
    JobReference = make_ref(),PidReferences = [spawn_monitor(fun() -> exit({JobReference,do_stuff(WorkSlice)}) end) || WorkSlice <- Workload],[receive
        {'DOWN',Reference,{JobReference,Result}} -> Result;
        {'DOWN',Result} -> {error,Result}
    end || {Pid,Reference} <- PidReferences].

,

要在进程之间传递信息，请使用!将消息发送到另一个进程的邮箱，然后使用receive clause从进程邮箱中提取消息。这是一个示例：

-module(a).
-compile(export_all).

%% Worker process:
say(From,2,0) ->
    From ! {self(),2]};
say(From,A,B) ->
    say(From,A-1,B-1).


%%  Main process:
loop(0) ->
    ok;
loop(Times) ->
    Pid = spawn(a,say,[self(),4,2]),receive  %%waits here for result before spawning another process--no concurrency
        {Pid,Result} ->
            io:fwrite( "L is ~w  ~n",[Result] )
    end,loop(Times-1).


%%  Test:
run() ->
    loop(4).

在外壳中：

7> c(a).   
a.erl:2: Warning: export_all flag enabled - all functions will be exported
{ok,a}

8> a:run().
L is [1,2]  
L is [1,2]  
ok

9> 

或者，您可以生成所有进程，然后读取它们进入的结果：

-module(a).
-compile(export_all).

%% Worker process:
say(From,0) ->
    From ! [1,2];
say(From,B-1).


%%  Main process:
loop(N) ->
    loop(N,N).

loop(0,Times) ->
    display_results(Times);
loop(N,Times) ->
    spawn(a,loop(N-1,Times).
 
display_results(0) -> 
    ok;
display_results(Times) ->
    receive
        Result ->
            io:format("L is ~w~n",[Result])
    end,display_results(Times-1).

%%  Test:
run() ->
    loop(4).

要确保您仅产生了receive条消息，请执行以下操作：

-module(a).
-compile(export_all).

%% Worker process:
say(From,B-1).


%%  Main process:
loop(Times) ->
    loop(Times,_Pids=[]).

loop(0,Pids) ->
    display_results(Pids);
loop(Times,Pids) ->
    Pid = spawn(a,loop(Times-1,[Pid|Pids]).


display_results([]) -> 
    ok;
display_results([Pid|Pids]) ->
    receive
        {Pid,Result} ->
            io:format("L is ~w~n",display_results(Pids).

%%  Test:
run() ->
    loop(4).

使用receive时存在一些风险，例如：如果工作进程在将消息发送到主进程之前崩溃，则在等待消息发送到主进程时，主进程将无限期地停留在接收中从崩溃的进程到达。一种解决方案：在接收中使用超时。另一个：使用spawn_monitor（）。