erlang的Socket参数含义

标签：

http://blog.csdn.net/pkutao/article/details/8572216

{ok, Listen} = gen_tcp:listen(?defPort, [binary, {packet, 2},{reuseaddr, true},{active, true}]),
%gen_tcp表用TCP连接
%binary表二进制流方式
%packet,2：表包头长度2字节
%reuseaddr, true:表多个实例可重用同一端口
% {active,true} 创建一个主动套字节(非阻塞)
% {active,false} 创建一个被动套字节(阻塞),如果为false表必须手工处理阻塞,否则阻塞在此处无法收听,当前我无法处理
%{active, once} 创建一个一次性被动套字节(阻塞),只收听一次后堵塞，必须调用inet:setopts(Socket, [{active, once}]),后才可收听下一条
% {active,once} 创建一个主动套字节仅接收一条消息,如想接收下一条必须再次激活(半阻塞)

packet是erlang网络编程中使用频率较高的一个参数，例如：

erlang 解决socket 数据粘包问题

我们知道，erlang实现的网络服务器性能非常高。erlang的高效不在于短短几行代码就能写出一个服务端程序，而在于不用太多代码，也能够写出一个高效的服务端程序。而这一切的背后就是erlang对很多网络操作实现了近乎完美的封装，使得我们受益其中。文章将讨论erlang gen_tcp 数据连包问题及erlang的解决方案。

数据连包问题，这个在client/server的通讯中很常见。就是，当client在极短的时间内发送多个包给server，这时server在接收数据的时候可能发生连包问题，就一次性接收这几个包的数据，导致数据都粘连在一起。

这里先讨论{packet, raw}或者{packet,0}的情况，分别看下{active, Boolean}的两种方式：

gen_tcp对socket数据封包的获取有以下2种方式，

1、{active, false} 方式通过 gen_tcp:recv(Socket, Length)  -> {ok, Data} | {error, Reason} 来接收。
2、{active, true} 方式以消息形式{tcp, Socket, Data} | {tcp_closed, Socket} 主动投递给线程。

对于第一种方式 gen_tcp:recv/2,3，如果封包的类型是{packet, raw}或者{packet,0}，就需要显式的指定长度，否则封包的长度是对端决定的，长度只能设置为0。如果长度Length设置为0，gen_tcp:recv/2,3会取出Socket接收缓冲区所有的数据

对于第二种方式，缓存区有多少数据，都会全部以消息{tcp, Socket, Data} 投递给线程。

以上就会导致数据连包问题，那么如何解决呢？

 {packet, PacketType}

现在再来看下 {packet, PacketType}，erlang的解释如下：

packet大致意义如下：

 {packet,  N}

也就是说，如果packet属性为1,2,4，可以保证server端一次接收的数据包大小。

下面我们以 {packet, 2} 做讨论。

gen_tcp 通信传输的数据将包含两部分：包头+数据。gen_tcp:send/2发送数据时，erlang会计算要发送数据的大小，把大小信息存放到包头中，然后封包发送出去。

所以在接收数据时，要根据包头信息，判断接收数据大小。使用gen_tcp:recv/2,3接收数据时，erlang会自动处理包头，获取封包数据。

下面写了个例子来说明，保存为 tcp_test.erl

[plain] view plaincopy

 

1. -module(tcp_test).  
2. -export([  
3.     start_server/0,  
4.     start_client_unpack/0, start_client_packed/0  
5.     ]).  
6.   
7. -define(PORT, 8888).  
8. -define(PORT2, 8889).  
9.   
10. start_server()->  
11.     {ok, ListenSocket} = gen_tcp:listen(?PORT, [binary,{active,false}]),  
12.     {ok, ListenSocket2} = gen_tcp:listen(?PORT2, [binary,{active,false},{packet,2}]),  
13.     spawn(fun() -> accept(ListenSocket) end),  
14.     spawn(fun() -> accept(ListenSocket2) end),  
15.     receive  
16.         _ -> ok  
17.     end.  
18.   
19. accept(ListenSocket)->  
20.     case gen_tcp:accept(ListenSocket) of  
21.         {ok, Socket} ->  
22.             spawn(fun() -> accept(ListenSocket) end),  
23.             loop(Socket);  
24.         _ ->  
25.             ok  
26.     end.  
27.   
28. loop(Socket)->  
29.     case gen_tcp:recv(Socket,0) of  
30.         {ok, Data}->  
31.             io:format("received message ~p~n", [Data]),  
32.             gen_tcp:send(Socket, "receive successful"),  
33.             loop(Socket);  
34.         {error, Reason}->  
35.             io:format("socket error: ~p~n", [Reason])  
36.     end.  
37.   
38. start_client_unpack()->  
39.     {ok,Socket} = gen_tcp:connect({127,0,0,1},?PORT,[binary,{active,false}]),  
40.     gen_tcp:send(Socket, "1"),  
41.     gen_tcp:send(Socket, "2"),  
42.     gen_tcp:send(Socket, "3"),  
43.     gen_tcp:send(Socket, "4"),  
44.     gen_tcp:send(Socket, "5"),  
45.     sleep(1000).  
46.   
47. start_client_packed()->  
48.     {ok,Socket} = gen_tcp:connect({127,0,0,1},?PORT2,[binary,{active,false},{packet,2}]),  
49.     gen_tcp:send(Socket, "1"),  
50.     gen_tcp:send(Socket, "2"),  
51.     gen_tcp:send(Socket, "3"),  
52.     gen_tcp:send(Socket, "4"),  
53.     gen_tcp:send(Socket, "5"),  
54.     sleep(1000).  
55.   
56. sleep(Count) ->  
57.     receive  
58.     after Count ->  
59.         ok  
60.     end.  

运行如下：

[plain] view plaincopy

 

1. C:\>erlc tcp_test.erl  
2. C:\>erl -s tcp_test start_server  
3. Eshell V5.10.2  (abort with ^G)  
4.   
5. 1> tcp_test:start_client_packed().  
6. received message <<"1">>  
7. received message <<"2">>  
8. received message <<"3">>  
9. received message <<"4">>  
10. received message <<"5">>  
11. ok  
12.   
13. 2> tcp_test:start_client_unpack().  
14. received message <<"12345">>  
15. ok  

字节序

字节序分为两类：Big-Endian和Little-Endian，定义如下：
a) Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
b) Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
其实还有一种网络字节序，为TCP/IP各层协议定义的字节序，为Big-Endian。

packet包头是以大端字节序（big-endian）表示。如果erlang与其他语言，比如C++，就要注意字节序问题了。如果机器的字节序是小端字节序（little-endian），就要做转换。

{packet, 2} ：[L1,L0 | Data]

{packet, 4} ：[L3,L2,L1,L0 | Data]

如何判断机器的字节序，以C++为例

[cpp] view plaincopy

 

1. BOOL IsBigEndian()    
2. {    
3.     int a = 0x1234;    
4.     char b =  *(char *)&a;  //通过将int强制类型转换成char单字节，通过判断起始存储位置    
5.     if( b == 0x12)    
6.     {    
7.         return TRUE;    
8.     }    
9.     return FALSE;    
10. }  

如何转换字节序，以C++为例

[cpp] view plaincopy

 

1. // 32位字数据  
2. #define LittletoBig32(A)   ((( (UINT)(A) & 0xff000000) >> 24) | \  
3.     (( (UINT)(A) & 0x00ff0000) >> 8)   | \  
4.     (( (UINT)(A) & 0x0000ff00) << 8)   | \  
5.     (( (UINT)(A) & 0x000000ff) << 24))  
6.   
7. // 16位字数据  
8. #define LittletoBig16(A)   (( ((USHORT)(A) & 0xff00) >> 8)    | \  
9.     (( (USHORT)(A) & 0x00ff) << 8))  

参考

http://blog.csdn.net/mycwq/article/details/18359007

http://www.erlang.org/doc/man/inet.html#setopts-2

seq_loop(Listen).

listen_socket(Socket,Mode)->
receive 
{tcp,Socket,Bin} ->
%process_req(Bin),
%MsgQueueSize->获得有多少个消息包积压,先使用{active, true}，如果判断到接收到的消息包太多，再改成 {active, once}。
{message_queue_len, MsgQueueSize} = erlang:process_info(self(),message_queue_len),
io:format("Server received binary = ~p~n",[Bin]),
io:format("Queue size is ~p~n", [MsgQueueSize]),
if
(MsgQueueSize > 500) and (Mode =:= active_true) ->
inet:setopts(Socket, [{active, once}]), %再次调用收听，开始收听下一条信息 
listen_socket(Socket, active_once);
(MsgQueueSize < 10) and (Mode =:= active_once) ->
inet:setopts(Socket, [{active, true}]),   
listen_socket(Socket, active_true)
true->
io:format("Queue size is ~p~n", [MsgQueueSize]),   
listen_socket(Socket, Mode)
end;
{tcp_closed,Socket} ->
io:format("有人下线 =>~n"),
io:format("Client socket closed ~n")
end.

erlang的Socket参数含义

标签：

原文地址：http://www.cnblogs.com/fvsfvs123/p/4286230.html