📅 最后修改于: 2020-11-04 06:00:42 🧑 作者: Mango
Erlang中的并行编程需要具有以下基本原理或过程。
列表包括以下原则-
创建一个评估Fun的新并发过程。新进程与调用方并行运行。一个例子如下-
-module(helloworld).
-export([start/0]).
start() ->
spawn(fun() -> server("Hello") end).
server(Message) ->
io:fwrite("~p",[Message]).
上面程序的输出是-
“Hello”
向标识符为Pid的进程发送消息。消息发送是异步的。发送者不等待，而是继续其所做的事情。 ‘！’被称为发送运算符。
一个例子如下-
-module(helloworld).
-export([start/0]).
start() ->
Pid = spawn(fun() -> server("Hello") end),
Pid ! {hello}.
server(Message) ->
io:fwrite("~p",[Message]).
接收已发送到进程的消息。它具有以下语法-
receive
Pattern1 [when Guard1] ->
Expressions1;
Pattern2 [when Guard2] ->
Expressions2;
...
End
当消息到达进程时，系统会尝试将其与Pattern1匹配(可能有Guard 1)。如果成功，它将评估Expressions1。如果第一个模式不匹配，则尝试使用Pattern2，依此类推。如果没有任何一种模式匹配，则保存该消息以供以后处理，然后该过程等待下一条消息。
以下程序显示了使用所有3条命令的整个过程的示例。
-module(helloworld).
-export([loop/0,start/0]).
loop() ->
receive
{rectangle, Width, Ht} ->
io:fwrite("Area of rectangle is ~p~n" ,[Width * Ht]),
loop();
{circle, R} ->
io:fwrite("Area of circle is ~p~n" , [3.14159 * R * R]),
loop();
Other ->
io:fwrite("Unknown"),
loop()
end.
start() ->
Pid = spawn(fun() -> loop() end),
Pid ! {rectangle, 6, 10}.
关于上述程序，需要注意以下几点：
循环函数具有接收端循环。因此，发送消息时，它将由接收端循环处理。
产生一个新的过程，该过程进入循环函数。
消息通过Pid发送到生成的进程！消息命令。
上面程序的输出是-
Area of the Rectangle is 60
并发地，重要的是确定系统上允许的最大进程数。然后，您应该能够了解系统上可以同时执行多少个进程。
让我们看一个示例，该示例如何确定系统上可以执行的最大进程数。
-module(helloworld).
-export([max/1,start/0]).
max(N) ->
Max = erlang:system_info(process_limit),
io:format("Maximum allowed processes:~p~n" ,[Max]),
statistics(runtime),
statistics(wall_clock),
L = for(1, N, fun() -> spawn(fun() -> wait() end) end),
{_, Time1} = statistics(runtime),
{_, Time2} = statistics(wall_clock), lists:foreach(fun(Pid) -> Pid ! die end, L),
U1 = Time1 * 1000 / N,
U2 = Time2 * 1000 / N,
io:format("Process spawn time=~p (~p) microseconds~n" , [U1, U2]).
wait() ->
receive
die -> void
end.
for(N, N, F) -> [F()];
for(I, N, F) -> [F()|for(I+1, N, F)].
start()->
max(1000),
max(100000).
在任何具有良好处理能力的机器上，上述两个最大功能都会通过。以下是上述程序的输出示例。
Maximum allowed processes:262144
Process spawn time=47.0 (16.0) microseconds
Maximum allowed processes:262144
Process spawn time=12.81 (10.15) microseconds
有时，receive语句可能会永远等待永远不会出现的消息。这可能是出于多种原因。例如，我们的程序中可能存在逻辑错误，或者要向我们发送消息的进程在发送消息之前可能已崩溃。为避免此问题，我们可以将超时添加到接收语句。这设置了进程等待接收消息的最长时间。
以下是指定了超时的接收消息的语法
receive
Pattern1 [when Guard1] ->
Expressions1;
Pattern2 [when Guard2] ->
Expressions2;
...
after Time ->
Expressions
end
最简单的示例是创建一个轨枕函数，如以下程序所示。
-module(helloworld).
-export([sleep/1,start/0]).
sleep(T) ->
receive
after T ->
true
end.
start()->
sleep(1000).
上面的代码在实际退出之前将休眠1000Ms。
Erlang中的每个进程都有一个关联的邮箱。当您向该进程发送消息时，该消息将放入邮箱中。仅当程序评估接收语句时，才检查此邮箱。
以下是选择性接收语句的一般语法。
receive
Pattern1 [when Guard1] ->
Expressions1;
Pattern2 [when Guard1] ->
Expressions1;
...
after
Time ->
ExpressionTimeout
end
这就是上面的接收语句的工作方式-
当我们输入一个receive语句时，我们将启动一个计时器(但前提是表达式中存在一个after节)。
拿邮箱中的第一条消息，然后尝试将其与Pattern1，Pattern2等匹配。如果匹配成功，则会从邮箱中删除该邮件，并评估模式后面的表达式。
如果receive语句中的任何模式都不匹配邮箱中的第一条消息，则将从邮箱中删除第一条消息并将其放入“保存队列”。然后尝试邮箱中的第二条消息。重复此过程，直到找到匹配的消息，或者已检查邮箱中的所有消息。
如果邮箱中的所有邮件都不匹配，则该过程将被挂起，并将在下次将新邮件放入邮箱中时重新安排执行时间。请注意，当有新消息到达时，保存队列中的消息不会重新匹配；因此，新消息将不匹配。仅匹配新消息。
匹配邮件后，已放入保存队列中的所有邮件将按照到达过程的顺序重新输入到邮箱中。如果设置了计时器，则将其清除。
如果等待消息时计时器已过去，请评估表达式ExpressionsTimeout并将所有保存的消息按到达过程的顺序放回邮箱。