以下是示例：test_for_gen_server.erl
当进程在其邮箱中收到10000封邮件时，完成时间为0.043秒。当数字为50000时，它应该需要0.215秒，但实际情况是2.4秒，慢10倍。为什么呢？
Erlang/OTP 18 [erts-7.1] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:true]
Eshell V7.1 (abort with ^G)
1> test_for_gen_server:start_link().
{ok,<0.36.0>}
2> test_for_gen_server:test(10000).
ok
======gen_server: Times:10000 Cost:42863
3> test_for_gen_server:test(10000).
ok
======gen_server: Times:10000 Cost:43096
4> test_for_gen_server:test(10000).
ok
======gen_server: Times:10000 Cost:43223
5> test_for_gen_server:test(50000).
ok
======gen_server: Times:50000 Cost:2504395
6> test_for_gen_server:test(50000).
ok
======gen_server: Times:50000 Cost:2361987
7> test_for_gen_server:test(50000).
ok
======gen_server: Times:50000 Cost:2304715
答案 0 :(得分：7)
在评论之后，在这种情况下确实不是由邮箱的大小引起的，因为在gen_server邮箱消息总是匹配。请参阅receive loop。
事实证明，在这种情况下，较慢的执行是由于代码的额外复杂性，特别是由于需要由垃圾收集器释放的少量数据的多次分配（因此与之无关）邮箱的大小，但代码执行的次数。）
以下是您的代码的略微修改版本，主要区别在于在收到start消息后填充了消息队列。除了您的示例之外，还有其他7种变体，每种变体都略微修改/简化了循环版本。第二个循环基于您可以找到gen_server code。
-module (test_for_gen_server).
-behaviour (gen_server).
%% APIs
-export([test1/1, test2/1, test3/1, test4/1, test5/1, test6/1, test7/1,
test8/1, test9/1]).
%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
terminate/2, code_change/3]).
test1(N) ->
{ok, Pid} = gen_server:start_link(?MODULE, [], []),
Pid ! {start, N}.
test2(N) -> Pid = spawn(fun() -> loop2([undefined, 0]) end), Pid ! {start, N}.
test3(N) -> Pid = spawn(fun() -> loop3([undefined, 0]) end), Pid ! {start, N}.
test4(N) -> Pid = spawn(fun() -> loop4([undefined, 0]) end), Pid ! {start, N}.
test5(N) -> Pid = spawn(fun() -> loop5([undefined, 0]) end), Pid ! {start, N}.
test6(N) -> Pid = spawn(fun() -> loop6([undefined, 0]) end), Pid ! {start, N}.
test7(N) -> Pid = spawn(fun() -> loop7([undefined, 0]) end), Pid ! {start, N}.
test8(N) -> Pid = spawn(fun() -> loop8(undefined, 0) end), Pid ! {start, N}.
test9(N) -> Pid = spawn(fun() -> loop9({undefined, 0}) end), Pid ! {start, N}.
%%==============================================================================
init([]) ->
{ok, []}.
handle_call(_Request, _From, State) ->
{reply, nomatch, State}.
handle_cast(_Msg, State) ->
{noreply, State}.
handle_info({start, N}, _State) ->
do_test(N),
{A,B,C} = os:timestamp(),
Timestamp = (A * 1000000 + B) * 1000000 + C,
{noreply, [Timestamp, 0]};
handle_info(stop, [Timestamp, Times]) ->
{A,B,C} = os:timestamp(),
Timestamp1 = (A * 1000000 + B) * 1000000 + C,
Cost = Timestamp1 - Timestamp,
io:format("======gen_server: Times:~p Cost:~p~n", [Times, Cost]),
{stop, normal, []};
handle_info(_Info, [Timestamp, Times]) ->
{noreply, [Timestamp, Times + 1]}.
terminate(_Reason, _State) -> ok.
code_change(_OldVer, State, _Extra) -> {ok, State}.
do_test(0) -> self() ! stop;
do_test(N) -> self() ! a, do_test(N - 1).
%%==============================================================================
loop2(State) ->
Msg = receive
Input -> Input
end,
Reply = {ok, handle_info(Msg, State)},
handle_common_reply(Reply, Msg, State).
handle_common_reply(Reply, _Msg, _State) ->
case Reply of
{ok, {noreply, NState}} -> loop2(NState);
{ok, {stop, normal, _}} -> ok
end.
%%==============================================================================
loop3(State) ->
Msg = receive
Input -> Input
end,
Reply = {ok, handle_info(Msg, State)},
case Reply of
{ok, {noreply, NState}} -> loop3(NState);
{ok, {stop, normal, _}} -> ok
end.
%%==============================================================================
loop4(State) ->
Msg = receive
Input -> Input
end,
case handle_info(Msg, State) of
{noreply, NState} -> loop4(NState);
{stop, normal, _} -> ok
end.
%%==============================================================================
loop5(State) ->
receive
Input ->
case handle_info(Input, State) of
{noreply, NState} -> loop5(NState);
{stop, normal, _} -> ok
end
end.
%%==============================================================================
loop6(State) ->
receive
{start, _N} = Msg ->
{noreply, NState} = handle_info(Msg, State),
loop6(NState);
stop = Msg ->
{stop, normal, []} = handle_info(Msg, State);
Info ->
{noreply, NState} = handle_info(Info, State),
loop6(NState)
end.
%%==============================================================================
loop7([Timestamp, Times]) ->
receive
{start, N} ->
do_test(N),
{A,B,C} = os:timestamp(),
NTimestamp = (A * 1000000 + B) * 1000000 + C,
loop7([NTimestamp, 0]);
stop ->
{A,B,C} = os:timestamp(),
NTimestamp = (A * 1000000 + B) * 1000000 + C,
Cost = NTimestamp - Timestamp,
io:format("======Times:~p Cost:~p~n", [Times, Cost]);
_Info ->
loop7([Timestamp, Times + 1])
end.
%%==============================================================================
loop8(Timestamp, Times) ->
receive
{start, N} ->
do_test(N),
{A,B,C} = os:timestamp(),
NTimestamp = (A * 1000000 + B) * 1000000 + C,
loop8(NTimestamp, 0);
stop ->
{A,B,C} = os:timestamp(),
NTimestamp = (A * 1000000 + B) * 1000000 + C,
Cost = NTimestamp - Timestamp,
io:format("======Times:~p Cost:~p~n", [Times, Cost]);
_Info ->
loop8(Timestamp, Times + 1)
end.
%%==============================================================================
loop9({Timestamp, Times}) ->
receive
{start, N} ->
do_test(N),
{A,B,C} = os:timestamp(),
NTimestamp = (A * 1000000 + B) * 1000000 + C,
loop9({NTimestamp, 0});
stop ->
{A,B,C} = os:timestamp(),
NTimestamp = (A * 1000000 + B) * 1000000 + C,
Cost = NTimestamp - Timestamp,
io:format("======Times:~p Cost:~p~n", [Times, Cost]);
_Info ->
loop9({Timestamp, Times + 1})
end.
结果：
28> c(test_for_gen_server).
{ok,test_for_gen_server}
29> test_for_gen_server:test1(50000).
{start,50000}
======gen_server: Times:50000 Cost:2285054
30> test_for_gen_server:test2(50000).
{start,50000}
======gen_server: Times:50000 Cost:2170294
31> test_for_gen_server:test3(50000).
{start,50000}
======gen_server: Times:50000 Cost:1520796
32> test_for_gen_server:test4(50000).
{start,50000}
======gen_server: Times:50000 Cost:1526084
33> test_for_gen_server:test5(50000).
{start,50000}
======gen_server: Times:50000 Cost:1510738
34> test_for_gen_server:test6(50000).
{start,50000}
======gen_server: Times:50000 Cost:1496024
35> test_for_gen_server:test7(50000).
{start,50000}
======Times:50000 Cost:863876
36> test_for_gen_server:test8(50000).
{start,50000}
======Times:50000 Cost:5830
47> test_for_gen_server:test9(50000).
{start,50000}
======Times:50000 Cost:640157
您可以看到每次更改后执行时间越来越小。请注意test2和test3之间的区别，其中代码中唯一的区别是附加函数调用。特别要注意test7和test8之间的巨大差异，其中代码的唯一区别是在{1的情况下每次执行循环时额外创建和销毁双元素列表{1}}。
最后一个循环可以在不使用VM虚拟寄存器的情况下在堆栈上分配任何内容的情况下执行，因此速度最快。其他循环总是在堆栈上分配一些数据，然后必须由垃圾收集器定期释放。
注意
刚刚添加test7以显示在函数之间传递参数时使用元组而不是列表通常会提供更好的性能。
以前的答案仅供参考
这是因为test9子句需要将传入消息与该子句中可能出现的模式进行匹配。它从邮箱中获取每条消息，并尝试将其与模式进行匹配。第一个匹配的是处理。
因此，如果队列因为消息不匹配而建立，则处理每个新传入消息所需的时间越来越长（因为匹配总是从队列中的第一条消息开始）。
因此，按照Joe Armstrong in his Phd thesis（第5.8节）的建议，始终清除gen服务器中的未知消息是一种好习惯。
本文将详细解释它：Erlang explained: Selective receive，并在前面提到的Joe Armstrong论文的第3.4节中进行了解释。
答案 1 :(得分：1)
在蛋汤饭的回复中非常有用：
从Erlang / OTP 20开始，可以使用进程标志message_queue_data = off_heap来避免大型邮箱上的GC变慢。请参阅process_flag(Flag :: message_queue_data, MQD) here的文档。请参阅Erlang standard library中的示例：
init(_) ->
%% The error logger process may receive a huge amount of
%% messages. Make sure that they are stored off heap to
%% avoid exessive GCs.
process_flag(message_queue_data, off_heap),
{ok, []}.
或者，在使用erlang：spawn_opt / 2创建进程时，可以使用{message_queue_data，off_heap}选项。
答案 2 :(得分：0)
最近，我在Elixir遇到了同样的问题，最后我找到答案in this paper
第3节.ellang的内存架构以流程为中心。每个进程分配和管理自己的内存区域，通常包括PCB，专用堆栈和私有堆。
这导致了缺点：高内存碎片
即使该存储区域中存在大量未使用的空间，进程也不能利用另一进程的存储器（例如堆）。这通常意味着默认情况下进程只能分配少量内存。这反过来通常会导致对垃圾收集器的大量调用。
如此庞大的邮箱大小会导致整个系统变慢。