erlang学习五

信息技术领域关键组件与应用

最新推荐文章于 2025-07-18 11:29:07 发布

原创最新推荐文章于 2025-07-18 11:29:07 发布 · 389 阅读

0 ·

CC 4.0 BY-SA版权

erlang 专栏收录该内容

7 篇文章

订阅专栏

本文深入探讨了信息技术领域的核心组件及其应用，包括但不限于前端开发、后端开发、移动开发、游戏开发、大数据开发等细分领域。通过实例解析，展示了各技术领域的关键实践和最新趋势，旨在帮助开发者深化理解并灵活运用这些技术。

通信：

whereis（进程名）判断节点是否存在该进程名，存在则返回进程PID，否则返回undefined

<span style="font-size:18px;"><span style="font-size:18px;">-module(tut).
-export([logon/1,logoff/0,send/2,clint/2])<span style="font-family:Arial, Helvetica, sans-serif;">.</span></span><span style="font-size:18px;">


%%% %%% %%% %%% command

server_node() ->
	fa.


logon(Name) ->
	case whereis(mess_client) of
		undefined ->
			register(mess_client,spawn(tut,client,[server_node(),Name]));
		_ -> already_logon
	end.


logoff() ->
	mess_client ! logoff.


send(ToName,Message) ->
	case whereis(mess_client) of
		undefined ->
			not_loged;
		_ ->
			mess_client ! {message_to,ToName,Message}
	end.

%%% %%% %%% %%% client

client(Server_Node,Name) ->
	{messager,Server_Node} ! {self(),logon,Name},
	await_result(),
	client(Server_Node).


await_result() ->
	receive
		{messager,stop,Why} ->
			io:format("stop, ~p~n",[Why]),
			exit(normal);
		{messager,What} ->
			io:format("~p~n",[What])
	end.


client(Server_Node) ->
	receive
		logoff ->
			{messager,Server_Node} ! {self(),logoff},
			exit(normal);
		{message_to,ToName,Message} ->
			{messager,Server_Node} ! {self(),message,ToName,Message},
			await_result();
		{message_from,Name,Message} ->
			io:format("message_from ~p: ~p~n",[Name,Message])
	end,</span><pre name="code" class="plain"><span style="white-space:pre">	</span>client(Server_Node).</span>

kememmber(值,位置，列表）查找是否列表中每个数组在指定位置是该值，返回true,false；

keydelete同上，删除操作，返回列表；

keyserch同上，查找操作，存在返回{value,列表元素}，否则返回false

<span style="font-size:18px;"><span style="font-size:18px;">-module(tut4).
-export([start_server/0]).


start_server() ->
	register(messager,spawn(tut4,server,[[]])).


server(User_List) ->
	receive
		{From,logon,Name} ->
			NewLs = server_Logon(From,Name,User_List),
			server(NewLs);
		{From,logoff} ->
			NewLs = server_Logoff(From,User_List),
			server(NewLs);
		{From,message,ToName,Message} ->
			server_transfer(From,ToName,Message,User_List),
			io:format("list is now: ~p~n",[User_List]),
			server(User_List)
	end.


server_Logon(From,Name,User_List) ->
	case lists:keymember(Name,2,User_List) of
		true ->
			From ! {messager,stop,user_exit},
			User_List;
		false ->
			From ! {messager,loged_on},
			[{From,Name} | User_List]
	end.

server_Logoff(From,User_List) ->
	list:keydelete(From,1,User_List).


server_transfer(From,ToName,Message,User_List) ->
	case list:keysearch(From,1,User_List) of
		{value,{From,Name}} ->
			server_transfer(From,Name,ToName,Message,User_List);
		false ->
			From ! {messager,stop,you_are_not_logon}
	end.


server_transfer(From,Name,ToName,Message,User_List) ->
	case list:keysearch(ToName,2,User_List) of
		{value,{ToPID,ToName}} ->
			ToPID ! {message_from,Name,Message},
			From ! {messager,sent};
		false ->
			From ! {messager,receiver_not_found}
	end.
</span></span></span>

鲁棒性:

上个例子如果client不退出，将一直持有该client。

Timeout:

当进入receive就会开始after 5000，当receive满足条件，timeout被取消；

否则直到5000毫秒执行after；

after必须放在receive最后；

<span style="font-size:18px;"><span style="font-size:18px;">-module(tut).
-export([start_pong/0,start_ping/1]).



start_pong() ->
	register(pong,spawn(tut,pong,[])).

pong() ->
	receive
		{ping,Ping_PID} ->
			io:format("pong receive ping~n"),
			Ping_PID ! pong,
			pong()
	after 5000 ->
		io:format("pong timed out~n")
	end.


start_ping(Pong_Node) ->
	spawn(tut,ping,[3,Pong_Node]).



ping(0,Pong_Node) ->
	io:format("ping finished ~n");


ping(N,Pong_Node) ->
	{pong,Pong_Node} ! {ping,self()},
	receive
		pong ->
			io:format("ping receive pong~n")
	end,
	ping(N - 1,Pong_Node).





</span></span>

link(Other_PID),在PID进程与当前进程建立连接；

当一个进程结束，它发送信号给连接的进程；

信号包含结束进程PID和结束原因；

默认行为当进程收到normal信号则忽略它且链接进程不会结束；

spawn_link和spawn一样，多个创建链接；

<span style="font-size:18px;">-module(tut).
-export([start/0,client/0,logoff/0,ping/1,isexit/0]).


isexit() ->
	case whereis(single) of
		undefined ->
			io:format("not exit~n");
		_ ->
			io:format("exit~n")
	end.


start() ->
	PID = spawn(tut,client,[]),
	register(single,PID),
	spawn(tut,ping,[PID]).


logoff() ->
	single ! logoff.


client() ->
	receive
		logoff ->
			exit(normal)
	end.


ping(PID) ->
	link(PID),
	exit(normal).
</span>

把函数ping 的exit(normal)改成exit(ping) 结果：

可以更改进程的默认行为，以便它收到异常退出信号时不会被杀死，但是所有的信号都会被转化为正常的消息，格式为{‘EXIT’,FromID,Reason}并被添加到消息队列中，设置方法：

process_flag(trap_exit,true),同样还有其他的标记；

该例子中client不会结束，但会收到信号消息，输出后结束，同样会捕获exit(normal)；

<span style="font-size:18px;"><span style="font-size:18px;">-module(tut).
-export([start/0,client/0,logoff/0,ping/1,isexit/0]).


isexit() ->
	case whereis(single) of
		undefined ->
			io:format("not exit~n");
		_ ->
			io:format("exit~n")
	end.


start() ->
	PID = spawn(tut,client,[]),
	register(single,PID),
	spawn(tut,ping,[PID]).


logoff() ->
	single ! logoff.


client() ->
	process_flag(trap_exit,true),
	receive
		logoff ->
			exit(normal);
		{'EXIT',From,Reson} ->
			io:format("pong get~p~n",[{'exit',From,Reson}])
	end.


ping(PID) ->
	link(PID),
	exit(ping).
</span></span>

Records and macros:

config.hrl

header file for configuration data

server_client_interface.hrl

interface definitions between the client and the messenger

user_interface.erl

functions for the user interface

client.erl

functions for the client side of the messenger

server.erl

functions for the server side of the messenger

-record(name_of_record,{field1,field2,...}}.

等价于：

-record({name_of_record,field1,field2,...}}.

<span style="font-size:18px;">%%% server_client_interface
-record(logon,{clientPID,name}).


-record(abort,{reason}).

-record(reply,{message}).

-record(logoff,{name}).
</span>

<span style="font-size:18px;">%%% server
-module(tut).
-export([start/0,server/1]).
-include("mess_interface.hrl").

start() ->
	process_flag(trap_exit,true),
	register(messenger,spawn(?MODULE,server,[[]])).


server(User_Ls) ->
	receive
		#logon{clientPID = FromPID,name = Name} ->
			NewLs = server_Logon(FromPID,Name,User_Ls),
			io:format("userlist ~p~n",[NewLs]),
			server(NewLs);
		{'EXIT',FromPID,_} ->
			NewLs = server_logoff(FromPID,User_Ls),
			io:format("userlist ~p~n",[NewLs]),
			server(NewLs);
		{logoff,FromPID} ->
			NewLs = server_logoff(FromPID,User_Ls),
			io:format("userlist ~p~n",[NewLs]),
			server(NewLs)
	end.


server_Logon(FromPID,Name,User_Ls) ->
	case lists:keymember(Name,2,User_Ls) of
		true ->
			FromPID ! #abort{reason = user_exit},
			User_Ls;
		false ->
			FromPID ! #reply{message = logon},
			link(FromPID),
			[{FromPID,Name} | User_Ls]
	end.



server_logoff(FromPID,User_Ls) ->
	list:keydelete(FromPID,1,User_Ls).
</span>

<span style="font-size:18px;">%%% client
-module(tut4).
-export([client/2]).
-include("mess_interface.hrl").

client(Server_Node,Name) ->
	{messenger,Server_Node} ! #logon{clientPID = self(),name = Name},
	await_result(),
	client(Server_Node).


await_result() ->
	receive
		#abort{reason = Why} ->
			io:format("abort ~p~n",[Why]);
		#reply{message = What} ->
			io:format("reply ~p~n",[What])
	end.


client(Server_Node) ->
	receive
		logoff ->
			exit(normal)
	end.

</span>

<span style="font-size:18px;">%%% config.hrl
-define(server_node,server@wsy).
</span>

<span style="font-size:18px;">%%% user_interface
-module(tut5).
-export([logon/1,logoff/0]).
-include("config.hrl").

logon(Name) ->
	case whereis(client) of
		undefined ->
			register(client,spawn(tut4,client,[?server_node,Name]));
		_ ->
			already_logon
	end.


logoff() ->
	client ! logoff.
</span>