第12章 并发编程

1.基本并发函数

• 1)Pid=spawn(Mod,Func,Args) : 创建一个新的并发进程来执行Mode模块中定义的Func()函数,args为参数
• 2)Pid ! Message : 像标识符为Pid的进程发送消息Message.消息发送时异步的,发送方并不等待,而是会继续之前的工作, ! 被称为发送操作符
• 3) receive
• Pattern1 [when Guard1] ->
• Ex1;
• Pattern2 [when Guard2] ->
• Ex2;
• end
• 当某个消息到达进程后,系统尝试将它与Pattern1匹配,成功则执行Ex1,否则继续匹配.

  %%area_server.erl
  -module(area_server).
  -export([loop/0]).
  
  loop() ->
      receive
          {rectangle,Width,Ht} ->
              io:format("Area of rectangle is ~p~n",[Width*Ht]),
              loop();
          {square,Side} ->
              io:format("Area of square is ~p~n",[Side*Side]),
              loop()
      end.
  
  
  1>c(area_server).
  2>Pid=spawn(area_server,loop,[]).
  <0.49.0>
  3>Pid ! {rectangle,6,10}.
  Area of rectangle is 60
  {rectangle,6,10}

   

2.实现客户端与服务端

• 1)服务端接收并响应客户端.

  需要实现 : 
  receive
      {From,{.....}} ->
          From! ........
          loop();
  ..........
  %From起到标识作用

   

• 2)添加远程过程调用函数,封装了向服务器发送请求和等待响应的代码

  rpc(Pid,Request)->
      Pid ! {self(),Request},%向服务器发送请求,同时绑定self()
      receive%等待响应
          Response ->
              Response
      end.

   

• 3)对response进行标识绑定,使客户端能够识别到服务端发送的信息

  receive
      {From,{.....}} ->
          From! {self(),........}
          loop();
  ..........
  同时:
  rpc(Pid,Request)->
      Pid ! {self(),Request},
      receive
          {Pid,Response} ->
          Response
      end.

   

• 故最终代码为:

  -module(server2).
  -export([loop/0,rpc/2]).
  
  rpc(Pid,Request) ->
      Pid!{self(),Request},
      receive
          {Pid,Response} ->
          Response
      end.
  loop()->
      receive
          {From,{rectangle,Width,Ht}} ->
              From!{self(),Width*Ht},
              loop();
          {From,{circle,R}}->
              From!{self(),3.14159*R*R},
              loop();
          {From,Other}->
              From!{self(),{error,Other}},
              loop()
      end.

   

• 4)我们还可以将spawn和rpc隐藏在模块中,故最后为:

  -module(server2).
  -export([start/0,area/2,loop/0]).
  
  start()->spawn(server2,loop,[]).
  area(Pid,What) ->
      rpc(Pid,What).
  rpc(Pid,Request) ->
      Pid!{self(),Request},
      receive
          {Pid,Response} ->
              Response
      end.
  loop()->
      receive
          {From,{rectangle,Width,Ht}} ->
              From!{self(),Width*Ht},
              loop();
          {From,{circle,R}}->
              From!{self(),3.14159*R*R},
              loop();
          {From,Other}->
              From!{self(),{error,Other}},
              loop()
      end.
  
  
  1>Pid=server2:start().
  server2:area(Pid,{rectangle,10,8}).

   

3.带超时的接收

  有时一条接收语句会因为消息迟迟不来而一直等下去,故可以给接收语句增加一个超时设置,设定进程等待接收消息的最长时间.

receive
    Pattern1 [when Guard1] ->
        Ex1;
    Pattern2 [when Guard2] ->
        Ex2;
    after Time ->
        Ex
end

4.只带超时的接收:可以让当前的进行挂起T毫秒

sleep(T) ->
    receive
        after T ->
        true
    end.

5.超时值为0的接收

flush_buffer() ->
    receive
        _Any ->
            flush_buffer()
        after 0 ->
            true
    end.
%该结构设定了超时值为0,可实现当邮箱为空时,也返回值,同时利用零超时也可以实现某种形式的"优先接收"

6.实现一个定时器

%%创建stimer.erl
-module(stimer).
-export([start/2,cancel/1]).

start(Time,Fun) -> 
    spawn(fun() -> timer(Time,Fun) end).%对spawn进行了内部隐藏
cancel(Pid) -> 
    Pid! cancel.%若是调用cancel,则返回cancel信息
timer(Time ,Fun) ->
    receive
        cancel ->%当调用cancel()方法后,返回cancel信息,捕捉到该信息后,则void退出程序
            void
        after Time ->%Time后执行Fun().
            Fun()
    end.

7.注册进程

• 1)register(AnAtom,Pid) :用AnAtom(一个原子)作为名称来注册进程Pid,如果AnAtom已被用于注册某个进程,这次注册就会失败
• 2)unregister(AnAtom) :移除与AnAtom关联的所有注册信息.
• 3)whereis(AnAtom) ->Pid|undefined :检查AnAtom是否已被注册,如果是就返回进程标识符Pid,如果没有找到与AnAtom关联的进程就返回原子undefined
• 4)registered() -> [AnAtom :: atom] :返回一个包含系统里所有注册进程的列表

1>Pid=spawn(area_server,loop,[]).
2>register(area,Pid).

故原来的调用方式:Pid!{rectangle,10,10}. 
转换为:area!{rectangle,10,10}.

 

8.尾递归

9.基本错误处理函数