erlang中socket知识点(转)

最新推荐文章于 2020-06-06 09:32:27 发布
最新推荐文章于 2020-06-06 09:32:27 发布
阅读量383 收藏 1
点赞数
分类专栏： Erlang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengmm521/article/details/78438705
版权 
   
   

    
    Erlang Socket
   
   

   
   

    
    a. 最核心的概念 － socket控制进程
   
   

   
   

    
    b. 基本的C/S结构的例子（服务器只能处理一个客户端连接）
   
   

   
   

    
    c. 顺序型服务器的例子（服务器顺序的处理客户端的请求，每次只能处理一个，处理完一个处
   
   

   
   

    
          理下一个）
   
   

   
   

    
    d. 并发型服务器的例子（服务器并发的处理多个客户端的请求）
   
   

   
   

    
    

   
   

   
   

    
    e. 控制逻辑 － 主动型消息接收（非阻塞）
   
   

   
   

    
    f. 控制逻辑 － 被动型消息接收（阻塞）
   
   

   
   

    
    g. 控制逻辑 － 混合型消息接收（半阻塞）
   
   

   
   

    
    

   
   

   
   

    
    

   
   

   
   

    
    1. 最基本的Erlang C/S结构的例子:
   
   

   
   

    
    <1> 创建一个socket的进程（调用gen_tcp:accept或gen_tcp:connect）也就是socket的
   
   

   
   

    
    	控制进程，这个socket接收到的所有数据都转发给控制进程，如果控制进程消亡，socket也
   
   

   
   

    
    	会自行关闭，可以调用gen_tcp:controlling_process(Socket, NewPid)来把一个socket
   
   

   
   

    
    	的控制进程改为新的进程。
   
   

   
   

    
    

   
   

   
   

    
    <2> 服务器端和客户端使用的{packet, N}的参数必须一致
   
   

   
   

    
    

   
   

   
   

    
    <3> 在接收到一个连接的时候，显示的设置socket的属性，是一个好的策略
   
   

   
   

    
          {ok, Socket} = gen_tcp:accept(Listen),
   
   

   
   

    
           inet:setopts(Socket, [{packet, 4}, {active, true}, {nodelay, true}])
   
   

   
   

    
    

   
   

   
   

    
    -module(server).
   
   

   
   

    
    -export([start/0]).
   
   

   
   

    
    

   
   

   
   

    
    start() ->
   
   

   
   

    
        {ok, Listen} = gen_tcp:listen(2345, [binary, {packet, 4},
   
   

   
   

    
    					                  {reuseaddr, true},
   
   

   
   

    
    					                  {active, true}]),
   
   

   
   

    
        {ok, Socket} = gen_tcp:accept(Listen),
   
   

   
   

    
        gen_tcp:close(Listen),
   
   

   
   

    
        loop(Socket).
   
   

   
   

    
    

   
   

   
   

    
    loop(Socket) ->
   
   

   
   

    
        receive
   
   

   
   

    
    	{tcp, Socket, Bin} ->
   
   

   
   

    
    	    io:format("received: ~p~n", [Bin]),
   
   

   
   

    
    	    gen_tcp:send(Socket, iolist_to_binary(["server#",Bin])),
   
   

   
   

    
    	    loop(Socket);
   
   

   
   

    
    	{tcp_closed, Socket} ->
   
   

   
   

    
    	    io:format("[~p] tcp_closed~n", [Socket]);
   
   

   
   

    
    	{tcp_error, Socket, Reason} ->
   
   

   
   

    
    	    io:format("[~p] tcp_error: ~p~n", [Socket, Reason])
   
   

   
   

    
        end.
   
   

   
   

    
    

   
   

   
   

    
    

   
   

   
   

    
    -module(client).
   
   

   
   

    
    -export([echo/1]).
   
   

   
   

    
    

   
   

   
   

    
    echo(Data) ->
   
   

   
   

    
        {ok, Socket} = gen_tcp:connect("localhost", 2345, [binary, {packet, 4}]),
   
   

   
   

    
        ok = gen_tcp:send(Socket, Data),
   
   

   
   

    
        receive
   
   

   
   

    
    	{tcp, Socket, Bin} ->
   
   

   
   

    
    	    io:format("~p~n", [Bin]),
   
   

   
   

    
    	    gen_tcp:close(Socket)
   
   

   
   

    
        end.
   
   

   
   

    
    

   
   

   
   

    
    2. 顺序型服务器的例子
   
   

   
   

    
    

   
   

   
   

    
    start() ->
   
   

   
   

    
        {ok, Listen} = gen_tcp:listen(2345, [binary, {packet, 4},
   
   

   
   

    
    					                   {reuseaddr, true},
   
   

   
   

    
    					                   {active, true}]),
   
   

   
   

    
        seq_accept(Listen).
   
   

   
   

    
    

   
   

   
   

    
    seq_accept(Listen) ->
   
   

   
   

    
        {ok, Socket} = gen_tcp:accept(Listen),
   
   

   
   

    
        loop(Socket),
   
   

   
   

    
        seq_accept(Listen).
   
   

   
   

    
    

   
   

   
   

    
    loop(Socket) … 不变
   
   

   
   

    
      
   
   

   
   

    
    3. 并发型服务器的例子
   
   

   
   

    
    

   
   

   
   

    
    start() ->
   
   

   
   

    
        {ok, Listen} = gen_tcp:listen(2345, [binary, {packet, 4},
   
   

   
   

    
    					 {reuseaddr, true},
   
   

   
   

    
    					 {active, true}]),
   
   

   
   

    
        spawn(fun() -> accept(Listen) end).
   
   

   
   

    
    

   
   

   
   

    
    accept(Listen) ->
   
   

   
   

    
        {ok, Socket} = gen_tcp:accept(Listen),
   
   

   
   

    
        spawn(fun() -> accept(Listen) end),
   
   

   
   

    
        loop(Socket).
   
   

   
   

    
    

   
   

   
   

    
    loop(Socket) … 不变
   
   

   
   

    
    

   
   

   
   

    
    

   
   

   
   

    
    4. 控制逻辑
   
   

   
   

    
    <1> {active, true} – 主动 socket － 非阻塞模式
   
   

   
   

    
          当数据到达系统之后，会向控制进程发送{tcp, Socket, Data}的消息，而控制进程无法控制
   
   

   
   

    
    	这些消息，一个独立的客户端可能向系统发送上万条消息，这些消息都会发送到控制进程，控制
   
   

   
   

    
    	进程无法控制挺掉这些消息。
   
   

   
   

    
    

   
   

   
   

    
    <2> {active, false} – 被动socket － 阻塞模式
   
   

   
   

    
          如果是被动socket, 则socket必须调用gen_tcp:recv(Socket, N)来接收数据，它尝试接收
   
   

   
   

    
    	N字节的数据，如果N为0，那么所有可用的字节都会返回。
   
   

   
   

    
    	默认是: gen_tcp:(Socket, N, infinity)，也即使无限等待直到有数据可以接收，所以是
   
   

   
   

    
          阻塞的模式。
   
   

   
   

    
    

   
   

   
   

    
    <3> {active, once} – 半主动socket
   
   

   
   

    
          会创建一个主动socket,可以接收一条消息，但这个 socket所接收一条消息以后，如果让它接
   
   

   
   

    
          收下一条消息，必须激活它。
   
   

   
   

    
          inet:setopts(Socket, [{active, once}]) – 激活Socket的方式
   
   

   
   

    
    

   
   

   
   

    
    5. 主动型接收 － 非阻塞模式－ 异步服务器
   
   

   
   

    
    

   
   

   
   

    
    {ok, Listen} = gen_tcp:listen( … {active, true}  … ),
   
   

   
   

    
    {ok, Socket} = gen_tcp:accept(Listen),
   
   

   
   

    
    loop(Socket).
   
   

   
   

    
    

   
   

   
   

    
    loop(Socket) ->
   
   

   
   

    
        receive
   
   

   
   

    
    	{tcp, Socket, Data} ->
   
   

   
   

    
             …;
   
   

   
   

    
    	{tcp_closed, Socket} ->
   
   

   
   

    
    	  ...
   
   

   
   

    
        end.
   
   

   
   

    
    

   
   

   
   

    
    6. 被动型接收 － 阻塞模式 – 同步服务器
   
   

   
   

    
    

   
   

   
   

    
    {ok, Listen} = gen_tcp:listen( … {active, false}  … ),
   
   

   
   

    
    {ok, Socket} = gen_tcp:accept(Listen),
   
   

   
   

    
    loop(Socket).
   
   

   
   

    
    

   
   

   
   

    
    loop(Socket) ->
   
   

   
   

    
        case gen_tcp:recv(Socket, 0) of
   
   

   
   

    
    	{ok, Data} ->
   
   

   
   

    
    	   …
   
   

   
   

    
    	   loop(Socket);
   
   

   
   

    
    	{error, closed} ->
   
   

   
   

    
    	   ...
   
   

   
   

    
        end.
   
   

   
   

    
    

   
   

   
   

    
    

   
   

   
   

    
    7. 混合型模式 － 半同步服务器
   
   

   
   

    
    

   
   

   
   

    
    {ok, Listen} = gen_tcp:listen( … {active, once}  … ),
   
   

   
   

    
    {ok, Socket} = gen_tcp:accept(Listen),
   
   

   
   

    
    loop(Socket).
   
   

   
   

    
    

   
   

   
   

    
    loop(Socket) ->
   
   

   
   

    
        receive
   
   

   
   

    
    	{tcp, Socket, Data} ->
   
   

   
   

    
             …
   
   

   
   

    
    	  inet:setopts(Socket, [{active, once}]),
   
   

   
   

    
    	  loop(Socket);
   
   

   
   

    
    	{tcp_closed, Socket} ->
   
   

   
   

    
    	  ...
   
   

   
   

    
        end.
   
   

   
   

    
    

   
   

   
   

    
    8. socket的出错处理：
   
   

   
   

    
    <1> 每个socket都对应一个控制进程，如果控制进程消亡，则socket也会自动关闭
   
   

   
   

    
    <2> 如果服务器端应为逻辑崩溃，那么服务器端的 socket会自动关闭，同时客户端也会收到
   
   

   
   

    
           {tcp_closed, Socket}的消息
转自： http://blog.csdn.net/wangyangkobe/article/details/9124427
下边是我写的一个socket的例子。自已试了，可以连接上。 

-module(gameSocketServer).
%% ====================================================================
%% API functions
%% ====================================================================
-export([start/0]).
%% ====================================================================
%% Internal functions
%% ====================================================================
start() ->
	{ok,Listen} = gen_tcp:listen(2345, [binary,{packet,0},{reuseaddr,true},{active,once}]),
	spawn(fun() -> accept(Listen) end).
accept(Listen) ->
	{ok,Socket} = gen_tcp:accept(Listen),
	spawn(fun() -> accept(Listen) end),
	loop(Socket).
loop(Socket) ->
	receive
		{tcp,Socket,Bin} ->
			io:format("received:~p~n", [Bin]),
			gen_tcp:send(Socket, iolist_to_binary(["server#",Bin])),
			inet:setopts(Socket, [{active,once}]),
			loop(Socket);
		{tcp_closed,Socket} ->
			io:format("[~p] tcp_closed~n",[Socket]);
		{tcp_error,Socket,Reason} ->
			io:format("[~p] tcp_error:~p ~n", [Socket,Reason])
	end.
woodcol
关注
专栏目录
基于erlang语言的socket通信
Mayday
08-07 1018
erlang语言实现socket聊天室关键词 erlang socket erlang语言是函数式编程语言，由Erlang之父Joe Amstrong编写出erlang原型，并在爱立信公司得到大规模应用，进而在通信行业有了一席之地，其优势在于高并发性、容错、高性能。socket是实现数据交互的最普遍的方式，Erlang/OTP中也融合了tcp协议，并通过OTP中的库简单的编程就能实现服务端、客户端的
Java知识点概览
qq_48403611的博客
08-03 3511
java后端开发常见面试题总结
erlang中socket知识点
wangyangkobe的专栏
06-18 3100
Erlang Socket a. 最核心的概念 － socket控制进程 b. 基本的C/S结构的例子（服务器只能处理一个客户端连接） c. 顺序型服务器的例子（服务器顺序的处理客户端的请求，每次只能处理一个，处理完一个处 理下一个） d. 并发型服务器的例子（服务器并发的处理多个客户端的请求） e. 控制逻辑 － 主动型消息接收（非阻塞） f. 控制逻辑 － 被动型消息接收（
Erlang TCP Socket
seloba
07-04 123
转载请注明，来自http://blog.csdn.net/skyman_2001一旦打开了一个使用ＴＣＰ连接的套接字，它就始终保持打开状态，直至任何一方关闭它或因为一个错误而终止。在建立一个连接时，一般为每一次请求产生一个新进程，只要有请求被处理，就保持这个进程的存活。 假设有一个监听进程，其任务是等待传入的ＴＣＰ请求。只要一个请求到达，响应该连接请求的进程就变成了接收进程，有２种方案： 1. 产...
erlang socket
心笑峰的csdn blog
11-27 188
目标是验证“将客户端连接的socket绑定到一个gen_server后，发送到socket 的消息将由gen_server的handle_info/2 处理”。 接收客户端socket 连接的server:   -module("myserver"). -export([start/2],[stop/0]). start()-&gt; %%监听端口 {ok,List...
Erlang 的Socket编程
12-08 7039
介绍英文原文我学习 Erlang 已经有一段时间了，想的是做一个网络游戏之类的东西。然而，我没有找到一个适合我水平的像样的 Erlang socket 编程教程。因此我决定自己写一个。我针对的是有一定编程经验的人，不过倒不需要对函数式编程有什么经验。还要了解一些TCP和Socket的基础知识，对Erlang多少有一点了解，这样效果会更好。我推荐看一下 Erlang 入门。
php实现与erlang的二进制通讯实例解析
10-25
了解了上述知识点后，我们可以总结出php与erlang间进行二进制通讯的基本流程：php端通过pack函数构造数据包，通过socket发送到erlang端；erlang端利用gen_tcp模块接收数据，并使用位语法匹配和解析二进制数据。双方...
erlang与delphi多客户端通讯
09-30
下面我们将详细探讨这些知识点。 1. **Erlang**： Erlang是一种静态类型的函数式编程语言，以其在并发、分布式计算和容错能力上的优势而闻名。Erlang的 OTP（开放电信平台）框架提供了强大的进程间通信机制，如...
Erlang的socket 编程简例
我相信......
03-07 2632
Erlang 中gen_tcp 用于编写TCP程序，gen_udp用于编写UDP程序。一个简单的TCP服务器echo示例： Start_echo_server()-> {ok,Listen}= gen_tcp:listen(1234,[binary,{packet,4},{reuseaddr,true},{active,true}]), {ok,socket}=get_tcp:accept(Listen), gen_tcp:close(Listen),
erlang基础知识点
红尘一傻帽的专栏
03-26 786
http://www.erlang.org/doc/man/STDLIB_app.html  函数速查手册 1、变量是不可改变的，必须以首字母大写开头 2、字符串就是小写字母，或者单引号引起来的字符串 3、赋值可以使用匹配模式 4、数据结构有元组{dd,aaa}，取值用匹配模式来取值{X, B}={dd,aaa}，就能取到X,B的值 5、数据结
Erlang分布式编程知识点
zyhserry的专栏
09-10 1196
1，什么是分布式程序？  Erlang分布式程序是设计用来在网络计算机上运行并且只可以通过消息传递来协调活动  2，为啥要写分布式程序？  1) 性能  通过将程序的不同部分分布到不同计算机来并行运行，以此提升性能（适用于密集型、CPU是瓶颈的计算）  2) 可靠性  通过将程序分布来构建容错系统，以此提升可靠性。如果一台机器失败了，我们可以在另一台机器上继续计算  3) 伸缩性
erlang的一些知识点补充
qq_37744360的博客
04-28 338
文章目录apply元数属性块表达式动态代码载入函数引用包含文件列表操作宏模式的匹配操作符整数进程字典下划线变量 apply 语法：apply（Mod,Func,[Arg1,Arg2,...,ArgN]） 用处：使得Mod，Func可以作为参数传入。 建议：尽量不使用，因为使用之后很多分析个工具无法使用。 元数 定义： 函数的参数个数 两个名称相同，元数不同的函数是完全不同的函数。 属性 语法...
erlang知识点小结
为天地立心，为生民立命，为往圣继绝学，为万世开太平
11-03 664
1、 动态产生原子会内存泄漏？怎么动态的产生原子？（erlang趣学指南第6页） 2、 函数中的最后一个表达式的执行结果会被自动作为返回值转递给调用者。 3、 在Erlang社区中，在模块的概括性注释（模块是做什么的，许可证等）以及模块的区段分隔注释（共有代码、私有代码、辅助函数等）中使用3个百分号。在所有其它需要放置在独立行中的注释使用2个百分号（%%），并和周边的代码采用同样的缩进。防止代码之...
Erlang基于Socket实现简单聊天室
hideto
08-11 321
1，chat_server.erl [code] -module(chat_server). -export([start/1]). -define(TCP_OPTIONS, [list, {packet, 0}, {active, false}, {reuseaddr, true}]). start(Port) -> Pid = spawn(fun() -> manage...
erlang 趣事之 socket通讯
养码青年
03-15 1420
现在看erlang的socket 编程，写了个demo，一直报错。为什么呢？经过指导说是我采用的短连接，没有及时关闭socket导致的。什么是短连接？什么是长连接？ 长连接与短连接 所谓长连接，指在一个TCP连接上可以连续发送多个数据包，在TCP连接保持期间，如果没有数据包发送，需要双方发检测包以维持此连接，一般需要自己做在线维持。  短连接是指通信双方有数据交互时，就建立一
erlang知识点小结2
为天地立心，为生民立命，为往圣继绝学，为万世开太平
06-06 316
获取进程邮箱数量的代码 erlang:process_info(self(), message_queue_len)
Erlang并发编程与OTP设计原则中文指南
手册分为多个部分，首先介绍了Erlang的基础知识。第1部分“入门”涵盖了Erlang的简单介绍，包括其并发编程特性的概述。1.2“顺序编程”讲解了Erlang Shell、模块和函数、元子（Atoms）、元组、列表以及如何将输出写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值