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.基本錯誤處理函式