Erlang入门备忘录（2）：并行编程

来源：互联网发布：vb.net 获取网页内容编辑：程序博客网时间：2024/04/28 13:25

3.1 进程

-module(tut14).

-export([start/0, say_something/2]).

say_something(What, 0) ->

done;

say_something(What, Times) ->

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

say_something(What, Times - 1).

start() ->

spawn(tut14, say_something, [hello, 3]),

spawn(tut14, say_something, [goodbye, 3]).

5> c(tut14).

{ok,tut14}

6> tut14:say_something(hello, 3).

hello

done

3.2 消息传送

-module(tut15).

-export([start/0, ping/2, pong/0]).

ping(0, Pong_PID) ->

Pong_PID ! finished,

io:format("ping finished~n", []);

ping(N, Pong_PID) ->

Pong_PID ! {ping, self()},

receive

pong ->

io:format("Ping received pong~n", [])

end,

ping(N - 1, Pong_PID).

pong() ->

receive

finished ->

io:format("Pong finished~n", []);

{ping, Ping_PID} ->

io:format("Pong received ping~n", []),

Ping_PID ! pong,

pong()

end.

start() ->

Pong_PID = spawn(tut15, pong, []),

spawn(tut15, ping, [3, Pong_PID]).

1> c(tut15).

{ok,tut15}

2> tut15: start().

<0.36.0>

Pong received ping

Ping received pong

Pong received ping

Ping received pong

Pong received ping

Ping received pong

ping finished

Pong finished

3.3 进程的注册名称

-module(tut16).

-export([start/0, ping/1, pong/0]).

ping(0) ->

pong ! finished,

io:format("ping finished~n", []);

ping(N) ->

pong ! {ping, self()},

receive

pong ->

io:format("Ping received pong~n", [])

end,

ping(N - 1).

pong() ->

receive

finished ->

io:format("Pong finished~n", []);

{ping, Ping_PID} ->

io:format("Pong received ping~n", []),

Ping_PID ! pong,

pong()

end.

start() ->

spawn(tut16, ping, [3]).

2> c(tut16).

{ok, tut16}

3> tut16:start().

<0.38.0>

Pong received ping

Ping received pong

Pong received ping

Ping received pong

Pong received ping

Ping received pong

ping finished

Pong finished

3.4 分布式编程

-module(tut17).

-export([start_ping/1, start_pong/0, ping/2, pong/0]).

ping(0, Pong_Node) ->

{pong, Pong_Node} ! finished,

io:format("ping finished~n", []);

ping(N, Pong_Node) ->

{pong, Pong_Node} ! {ping, self()},

receive

pong ->

io:format("Ping received pong~n", [])

end,

ping(N - 1, Pong_Node).

pong() ->

receive

finished ->

io:format("Pong finished~n", []);

{ping, Ping_PID} ->

io:format("Pong received ping~n", []),

Ping_PID ! pong,

pong()

end.

start_pong() ->

start_ping(Pong_Node) ->

spawn(tut17, ping, [3, Pong_Node]).

%%----------------------------------------------

-module(tut18).

-export([start/1, ping/2, pong/0]).

ping(0, Pong_Node) ->

{pong, Pong_Node} ! finished,

io:format("ping finished~n", []);

ping(N, Pong_Node) ->

{pong, Pong_Node} ! {ping, self()},

receive

pong ->

io:format("Ping received pong~n", [])

end,

ping(N - 1, Pong_Node).

pong() ->

receive

finished ->

io:format("Pong finished~n", []);

{ping, Ping_PID} ->

io:format("Pong received ping~n", []),

Ping_PID ! pong,

pong()

end.

start(Ping_Node) ->

spawn(Ping_Node, tut18, ping, [3, node()]).

3.5 大型示例

File messenger.erl:

%%% Message passing utility.

%%% User interface:

%%% logon(Name)

%%% One user at a time can log in from each Erlang node in the

%%% system messenger: and choose a suitable Name. If the Name

%%% is already logged in at another node or if someone else is

%%% already logged in at the same node, login will be rejected

%%% with a suitable error message.

%%% logoff()

%%% Logs off anybody at at node

%%% message(ToName, Message)

%%% sends Message to ToName. Error messages if the user of this

%%% function is not logged on or if ToName is not logged on at

%%% any node.

%%%

%%% One node in the network of Erlang nodes runs a server which maintains

%%% data about the logged on users. The server is registered as "messenger"

%%% Each node where there is a user logged on runs a client process registered

%%% as "mess_client"

%%%

%%% Protocol between the client processes and the server

%%% ----------------------------------------------------

%%%

%%% To server: {ClientPid, logon, UserName}

%%% Reply {messenger, stop, user_exists_at_other_node} stops the client

%%% Reply {messenger, logged_on} logon was successful

%%%

%%% To server: {ClientPid, logoff}

%%% Reply: {messenger, logged_off}

%%%

%%% To server: {ClientPid, logoff}

%%% Reply: no reply

%%%

%%% To server: {ClientPid, message_to, ToName, Message} send a message

%%% Reply: {messenger, stop, you_are_not_logged_on} stops the client

%%% Reply: {messenger, receiver_not_found} no user with this name logged on

%%% Reply: {messenger, sent} Message has been sent (but no guarantee)

%%%

%%% To client: {message_from, Name, Message},

%%%

%%% Protocol between the "commands" and the client

%%% ----------------------------------------------

%%%

%%% Started: messenger:client(Server_Node, Name)

%%% To client: logoff

%%% To client: {message_to, ToName, Message}

%%%

%%% Configuration: change the server_node() function to return the

%%% name of the node where the messenger server runs

-module(messenger).

-export([start_server/0, server/1, logon/1, logoff/0, message/2, client/2]).

%%% Change the function below to return the name of the node where the

%%% messenger server runs

server_node() ->

messenger@bill.

%%% This is the server process for the "messenger"

%%% the user list has the format [{ClientPid1, Name1},{ClientPid22, Name2},...]

server(User_List) ->

receive

{From, logon, Name} ->

New_User_List = server_logon(From, Name, User_List),

server(New_User_List);

{From, logoff} ->

New_User_List = server_logoff(From, User_List),

server(New_User_List);

{From, message_to, To, Message} ->

server_transfer(From, To, Message, User_List),

io:format("list is now: ~p~n", [User_List]),

server(User_List)

end.

%%% Start the server

start_server() ->

%%% Server adds a new user to the user list

server_logon(From, Name, User_List) ->

%% check if logged on anywhere else

case lists:keymember(Name, 2, User_List) of

true ->

From ! {messenger, stop, user_exists_at_other_node}, %reject logon

User_List;

false ->

From ! {messenger, logged_on},

[{From, Name} | User_List] %add user to the list

end.

%%% Server deletes a user from the user list

server_logoff(From, User_List) ->

lists:keydelete(From, 1, User_List).

%%% Server transfers a message between user

server_transfer(From, To, Message, User_List) ->

%% check that the user is logged on and who he is

case lists:keysearch(From, 1, User_List) of

false ->

From ! {messenger, stop, you_are_not_logged_on};

{value, {From, Name}} ->

server_transfer(From, Name, To, Message, User_List)

end.

%%% If the user exists, send the message

server_transfer(From, Name, To, Message, User_List) ->

%% Find the receiver and send the message

case lists:keysearch(To, 2, User_List) of

false ->

From ! {messenger, receiver_not_found};

{value, {ToPid, To}} ->

ToPid ! {message_from, Name, Message},

From ! {messenger, sent}

end.

%%% User Commands

logon(Name) ->

case whereis(mess_client) of

undefined ->

spawn(messenger, client, [server_node(), Name]));

_ -> already_logged_on

end.

logoff() ->

mess_client ! logoff.

message(ToName, Message) ->

case whereis(mess_client) of % Test if the client is running

undefined ->

not_logged_on;

_ -> mess_client ! {message_to, ToName, Message},

end.

%%% The client process which runs on each server node

client(Server_Node, Name) ->

{messenger, Server_Node} ! {self(), logon, Name},

await_result(),

client(Server_Node).

client(Server_Node) ->

receive

logoff ->

{messenger, Server_Node} ! {self(), logoff},

exit(normal);

{message_to, ToName, Message} ->

{messenger, Server_Node} ! {self(), message_to, ToName, Message},

await_result();

{message_from, FromName, Message} ->

io:format("Message from ~p: ~p~n", [FromName, Message])

end,

client(Server_Node).

%%% wait for a response from the server

await_result() ->

receive

{messenger, stop, Why} -> % Stop the client

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

exit(normal);

{messenger, What} -> % Normal response

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

end.

To use this program you need to:

configure the server_node() function

copy the compiled code (messenger.beam) to the directory on each computer where you start Erlang.

In the following example of use of this program, I have started nodes on four different computers, but if you don't have

that many machines available on your network, you could start up several nodes on the same machine.

We start up four Erlang nodes, messenger@super, c1@bilbo, c2@kosken, c3@gollum.

First we start up a the server at messenger@super:

(messenger@super)1> messenger:start_server().

true

Now Peter logs on at c1@bilbo:

(c1@bilbo)1> messenger:logon(peter).

true

logged_on

James logs on at c2@kosken:

(c2@kosken)1> messenger:logon(james).

true

logged_on

and Fred logs on at c3@gollum:

(c3@gollum)1> messenger:logon(fred).

true

logged_on

Now Peter sends Fred a message:

(c1@bilbo)2> messenger:message(fred, "hello").

sent

And Fred receives the message and sends a message to Peter and logs off:

Message from peter: "hello"

(c3@gollum)2> messenger:message(peter, "go away, I'm busy").

sent

(c3@gollum)3> messenger:logoff().

logoff

James now tries to send a message to Fred:

(c2@kosken)2> messenger:message(fred, "peter doesn't like you").

receiver_not_found

But this fails as Fred has already logged off.

First let's look at some of the new concepts we have introduced.

There are two versions of the server_transfer function, one with four arguments (server_transfer/4) and one with five

(server_transfer/5). These are regarded by Erlang as two separate functions.

Note how we write the server function so that it calls itself, server(User_List) and thus creates a loop. The Erlang

compiler is "clever" and optimizes the code so that this really is a sort of loop and not a proper function call. But

this only works if there is no code after the call, otherwise the compiler will expect the call to return and make a

proper function call. This would result in the process getting bigger and bigger for every loop.

We use functions in the lists module. This is a very useful module and a study of the manual page is recommended (erl -

man lists). lists:keymember(Key,Position,Lists) looks through a list of tuples and looks at Position in each tuple to see

if it is the same as Key. The first element is position 1. If it finds a tuple where the element at Position is the same

as Key, it returns true, otherwise false.

3> lists:keymember(a, 2, [{x,y,z},{b,b,b},{b,a,c},{q,r,s}]).

true

4> lists:keymember(p, 2, [{x,y,z},{b,b,b},{b,a,c},{q,r,s}]).

false

lists:keydelete works in the same way but deletes the first tuple found (if any) and returns the remaining list:

5> lists:keydelete(a, 2, [{x,y,z},{b,b,b},{b,a,c},{q,r,s}]).

[{x,y,z},{b,b,b},{q,r,s}]

lists:keysearch is like lists:keymember, but it returns {value,Tuple_Found} or the atom false.

There are a lot more very useful functions in the lists module.

An Erlang process will (conceptually) run until it does a receive and there is no message which it wants to receive in

the message queue. I say "conceptually" because the Erlang system shares the CPU time between the active processes in the

system.

A process terminates when there is nothing more for it to do, i.e. the last function it calls simply returns and doesn't

call another function. Another way for a process to terminate is for it to call exit/1. The argument to exit/1 has a

special meaning which we will look at later. In this example we will do exit(normal) which has the same effect as a

process running out of functions to call.

The BIF whereis(RegisteredName) checks if a registered process of name RegisteredName exists and return the pid of the

process if it does exist or the atom undefined if it does not.

You should by now be able to understand most of the code above so I'll just go through one case: a message is sent from

one user to another.

The first user "sends" the message in the example above by:

messenger:message(fred, "hello")

After testing that the client process exists:

whereis(mess_client)

and a message is sent to mess_client:

mess_client ! {message_to, fred, "hello"}

The client sends the message to the server by:

{messenger, messenger@super} ! {self(), message_to, fred, "hello"},

and waits for a reply from the server.

The server receives this message and calls:

server_transfer(From, fred, "hello", User_List),

which checks that the pid From is in the User_List:

lists:keysearch(From, 1, User_List)

If keysearch returns the atom false, some sort of error has occurred and the server sends back the message:

From ! {messenger, stop, you_are_not_logged_on}

which is received by the client which in turn does exit(normal) and terminates. If keysearch returns {value,{From,Name}}

we know that the user is logged on and is his name (peter) is in variable Name. We now call:

server_transfer(From, peter, fred, "hello", User_List)

Note that as this is server_transfer/5 it is not the same as the previous function server_transfer/4. We do another

keysearch on User_List to find the pid of the client corresponding to fred:

lists:keysearch(fred, 2, User_List)

This time we use argument 2 which is the second element in the tuple. If this returns the atom false we know that fred is

not logged on and we send the message:

From ! {messenger, receiver_not_found};

which is received by the client, if keysearch returns:

{value, {ToPid, fred}}

we send the message:

ToPid ! {message_from, peter, "hello"},

to fred's client and the message:

From ! {messenger, sent}

to peter's client.

Fred's client receives the message and prints it:

{message_from, peter, "hello"} ->

io:format("Message from ~p: ~p~n", [peter, "hello"])

and peter's client receives the message in the await_result function.