Erlang中頻繁傳送遠端訊息要注意的問題

http://avindev.iteye.com/blog/76373

注：這篇文章可能會有爭議，歡迎提出意見 

在Erlang中，如果要實現兩個遠端節點之間的通訊，就需要通過網路來實現，對於訊息傳送，是使用TCP。如果要在兩個節點間頻繁傳送訊息，比如每秒幾百上千條，那樣就要注意了。 

無論是網遊伺服器開發的書籍，或是經驗老道的工程師，都會告訴你，在傳送資料包時，儘可能把小的訊息組合為一個比較大的包來傳送，畢竟一個TCP包的頭也很大，首先是浪費頻寬，其次呼叫底層傳送的指令也是有開銷的。有工程師告訴我，一般每秒大概是2W次左右。 

簡單測試一下，先是程式碼 

一個接收訊息並馬上拋棄的Server： 

start() ->
    register(nullserver, self()),
    loop().

loop() ->
    receive
    Any ->
        loop() %drop message and loop
    end.

一個在迴圈中向它傳送訊息的Client： 

start() ->
    start_send(100).

start_send(0) ->
    ok;
start_send(N) ->
    {nullserver, 'foo@192.168.0.3'} ! hi,
    start_send(N-1).

然後開啟截包工具，執行server和client，擷取到接近200個包的傳送和接收記錄，其中，大部分是這樣的資料： 

引用

00 14 78 B9 14 BC 00 11-11 9F 91 1A 08 00 45 00 
00 45 EE 77 40 00 80 06-80 E4 C0 A8 00 CC DB E8 
ED F9 13 58 C1 C6 AA 4E-59 F2 38 CF 22 2D 50 18 
FF 19 B9 EE 00 00 00 00-00 19 70 83 68 04 61 06 
67 43 CC 00 00 00 01 00-00 00 00 02 43 05 43 BD 
83 43 BF                                     

引用

00 14 78 B9 14 BC 00 11-11 9F 91 1A 08 00 45 00 
00 45 EE 78 40 00 80 06-80 E3 C0 A8 00 CC DB E8 
ED F9 13 58 C1 C6 AA 4E-5A 0F 38 CF 22 2D 50 18 
FF 19 B9 D1 00 00 00 00-00 19 70 83 68 04 61 06 
67 43 CC 00 00 00 01 00-00 00 00 02 43 05 43 BD 
83 43 BF                                      

實際上，只有從 00 00-00 19 這裡開始，才是TCP包的內容，前面都是底層協議的資料，就是這樣的資料包傳送了100次，浪費是巨大的。而且，在訊息傳送後，還收到同樣數目類似 

引用

00 11 11 9F 91 1A 00 14-78 B9 14 BC 08 00 45 00 
00 28 8C FC 40 00 32 06-30 7D DB E8 ED F9 C0 A8 
00 CC C1 C6 13 58 38 CF-22 2D AA 4E 59 F2 50 10 
19 20 D7 01 00 00 00 00-00 00 00 00 

          

這樣的響應包，也浪費著頻寬。 


從目前我所閱讀過的文件來看，暫時沒有有關如何快取這些訊息定期一併傳送的引數設定。那麼有什麼解決辦法，我自己有兩種。 

一種是將要傳送的一批Message打包到一個list傳送，接收方從list中取出所有message並處理。 

另一種是通過一個Proxy，傳送方不通過 {Name, Node} ! Message 這種方式來傳送，而是通過一個本地的Proxy Process，代理會將所有傳送到某個節點的訊息累積起來，定時批量傳送過去；接收方也有一個Listening Process，它接收批量的Message，遍歷後傳送給本地的相應程式。 

這裡是我初步寫出來的實現，不太漂亮，僅供參考～ 

message_agent.erl: 實現訊息的批量傳送，接收和轉發 

-module(message_agent).
-export([listen/0, proxy/2, block_exit/1]).
-export([loop_receive/0]).
-define(MAX_BATCH_MESSAGE_SIZE, 50).

listen() ->
    io:format("Message agent server start listen~n"),
    spawn(fun() -> register('MsgServerAgent', self()), loop_receive() end),
    ok.

loop_receive() ->
    receive
    {forward_message, PName, Messages} ->
        forward_messages(PName, Messages),
            loop_receive();
    Any ->
        message_agent:loop_receive()
    end.

forward_messages(PName, []) ->
    ok;
forward_messages(PName, [H|T]) ->
    %io:format("Forward message ~w to process ~w~n", [H, PName]),
    catch PName ! H,
    forward_messages(PName, T).


proxy(Node, PName) ->
    spawn_link(fun() -> handle_message_forward(Node, PName, []) end).

block_exit(Agent) ->
    Agent ! {block_wait, self()},
    receive
    {unblock} ->
        ok
    end.

handle_message_forward(Node, PName, Messages) ->
    receive
    {block_wait, Pid} ->
        catch send_batch(Node, PName, lists:reverse(Messages)),
        Pid ! {unblock};
    Any ->
        NewMessages = [Any|Messages],
        case length(NewMessages)>=?MAX_BATCH_MESSAGE_SIZE of
        true ->
            send_batch(Node, PName, lists:reverse(NewMessages)),
            handle_message_forward(Node, PName, []);
        false ->
            handle_message_forward(Node, PName, NewMessages)
        end
    after
    0 ->
        case length(Messages)>0 of
        true ->
            catch send_batch(Node, PName, lists:reverse(Messages));
        false ->
            ok
        end,
        handle_message_forward(Node, PName, [])
    end.

send_batch(Node, PName, Messages) ->
    %io:format("Send batch message, size ~p~n", [length(Messages)]),
    {'MsgServerAgent', Node} ! {forward_message, PName, Messages}.

使用方式很簡單，在接收Message的一端呼叫 message_agent:listen() 啟動監聽代理，客戶端使用 register(agent, message_agent:proxy(?NODE, 'MsgServer')) 的方式啟動代理程式，訊息傳送給這個代理程式就可以了。下面是我寫的簡單例子： 

-module(message_server).
-export([start/0]).
-define(TIMEOUT_MS, 1000).

start() ->
    io:format("Message server start~n"),
    register('MsgServer', self()),
    message_agent:listen(),
    loop_receive(0).

loop_receive(Count) ->
    receive
    Any ->
        %io:format("Receive msg ~w~n", [Any]),
            loop_receive(Count+1)
    after
    ?TIMEOUT_MS ->
        if
        Count>0 ->
            io:format("Previous receive msg count: ~p~n", [Count]),
            loop_receive(0);
        true ->
            loop_receive(0)
        end
    end.

-module(message_client).
-define(NODE, 'msgsrv@192.168.0.3').
-define(COUNT, 20000).
-export([start/0]).

start() ->
    statistics(wall_clock),
    register(agent, message_agent:proxy(?NODE, 'MsgServer')),
    send_loop(?COUNT).

send_loop(0) ->
    message_agent:block_exit(agent),
    {_, Interval} = statistics(wall_clock),
    io:format("Finished ~p sends in ~p ms, exiting...~n", [?COUNT, Interval]);
send_loop(Count) ->
    agent ! {self(), lalala},
    send_loop(Count-1).

這裡要注意的是，訊息傳送端和接收端都是由一個單獨的程式來處理訊息。在Erlang的預設堆實現，是私有堆，本地程式間的訊息傳送是需要拷貝的，在資料量大的時候，該程式堆的垃圾回收會相當頻繁。