Erlang—並發編程

Erlang中的process——進程是輕量級的，並且進程間無共用。查了很多資料，似乎沒人說清楚輕量級進程算是什麼概念，繼續尋找中。。。閑話不 提，進入並發編程的世界。本文算是學習筆記，也可以說是《Concurrent Programming in ERLANG》第五張的簡略翻譯。
1.進程的建立
    進程是一種自包含的、分隔的計算單元，並與其他進程並發運行在系統中，在進程間並沒有一個繼承體系，當然，應用開發人員可以設計這樣一個繼承體系。
    進程的建立使用如下文法：java 代碼

1. Pid = spawn(Module, FunctionName, ArgumentList)  

spawn接受三個參數：模組名，函數名以及參數列表，並返回一個代表建立的進程的標識符（Pid）。
如果在一個已知進程Pid1中執行：java 代碼

1. Pid2 = spawn(Mod, Func, Args)  

那麼，Pid2僅僅能被Pid1可見，Erlang系統的安全性就構建在限制進程擴充的基礎上。

2.處理序間通訊
    Erlang進程間的通訊只能通過發送訊息來實現，訊息的發送使用!符號：java 代碼

1. Pid ! Message  

    其中Pid是接受訊息的進程標記符，Message就是訊息。接受方和訊息可以是任何的有效Erlang結構，只要他們的結果返回的是進程標記符和訊息。
    訊息的接受是使用receive關鍵字，文法如下：java 代碼

1. receive  
2.        Message1 [when Guard1] ->  
3.            Actions1 ;  
4.        Message2 [when Guard2] ->  
5.            Actions2 ;  
6.   
7. end  

    每一個Erlang進程都有一個“郵箱”，所有發送到進程的訊息都按照到達的順序儲存在“郵箱”裡，上面所示的訊息Message1,Message2， 當它們與“郵箱”裡的訊息匹配，並且約束（Guard）通過，那麼相應的ActionN將執行，並且receive返回的是ActionN的最後一條執行 語句的結果。Erlang對“郵箱”裡的訊息匹配是有選擇性的，只有匹配的訊息將被觸發相應的Action，而沒有匹配的訊息將仍然保留在“郵箱”裡。這 一機制保證了沒有訊息會阻塞其他訊息的到達。
    訊息到達的順序並不決定訊息的優先順序，進程將輪流檢查“郵箱”裡的訊息進行嘗試匹配。訊息的優先順序別下文再講。

    如何接受特定進程的訊息呢？答案很簡單，將發送方(sender)也附送在訊息當中，接收方通過模式比對決定是否接受，比如：java 代碼

1. Pid ! {self(),abc}  

給進程Pid發送訊息{self(),abc}，利用self過程得到發送方作為訊息發送。然後接收方：java 代碼

1. receive  
2.    {Pid1,Msg} ->  
3.   
4. end  

通過模式比對決定只有Pid1進程發送的訊息才接受。

3.一些例子
    僅說明下書中計數的進程例子,我添加了簡單注釋：java 代碼

1. -module(counter).  
2. -compile(export_all).  
3. % start()，返回一個新進程，進程執行函數loop  
4. start()->spawn(counter, loop,[0]).  
5. % 調用此操作遞增計數  
6. increment(Counter)->  
7.      Counter!increament.  
8. % 返回當前計數值  
9. value(Counter)->  
10.      Counter!{self(),value},  
11.      receive  
12.          {Counter,Value}->  
13.              %返回給調用方  
14.              Value  
15.          end.  
16.    %停止計數        
17. stop(Counter)->  
18.       Counter!{self(),stop}.  
19. loop(Val)->  
20.       receive  
21.           %接受不同的訊息，決定返回結果  
22.           increament->  
23.               loop(Val+1);  
24.           {From,value}->  
25.               From!{self(),Val},  
26.               loop(Val);  
27.           stop->  
28.              true;  
29.           %不是以上3種訊息，就繼續等待  
30.           Other->  
31.               loop(Val)  
32.        end.     
33.                
34.                           
35.           

調用方式：

java 代碼

1. 1> Counter1=counter:start().  
2. <0.30.0>  
3. 2> counter:value(Counter1).  
4. 0  
5. 3> counter:increment(Counter1).  
6. increament  
7. 4> counter:value(Counter1).  
8. 1  

基於進程的訊息傳遞機制可以很容易地實現有限狀態機器（FSM），狀態使用函數表示，而事件就是訊息。具體不再展開

4.逾時設定
    Erlang中的receive文法可以添加一個額外選項：timeout，類似：java 代碼

1. receive  
2.     Message1 [when Guard1] ->  
3.       Actions1 ;  
4.     Message2 [when Guard2] ->  
5.       Actions2 ;  
6.      
7.     after  
8.        TimeOutExpr ->  
9.           ActionsT  
10. end  

after之後的TimeOutExpr運算式返回一個整數time（毫秒層級），時間的精確程度依賴於Erlang在作業系統或者硬體的實現。如果在time毫秒內，沒有一個訊息被選中，逾時設定將生效，也就是ActionT將執行。time有兩個特殊值：
1)infinity(無窮大)，infinity是一個atom，指定了逾時設定將永遠不會被執行。
2) 0，逾時如果設定為0意味著逾時設定將立刻執行，但是系統將首先嘗試當前“郵箱”裡的訊息。

    逾時的常見幾個應用，比如掛起當前進程多少毫秒：java 代碼

1. sleep(Time) ->  
2.    receive  
3.      after Time ->  
4.     true  
5. end.  

比如清空進程的“郵箱”,丟棄“郵箱”裡的所有訊息：java 代碼

1. flush_buffer() ->  
2.    receive  
3.      AnyMessage ->  
4.        flush_buffer()  
5.    after 0 ->  
6.     true  
7. end.  

   
    將當前進程永遠掛起：java 代碼

1. suspend() ->  
2.      receive  
3.      after  
4.          infinity ->  
5.             true  
6.      end.  

       逾時也可以應用於實現定時器，比如下面這個例子，建立一個進程，這個進程將在設定時間後向自己發送訊息：java 代碼

1. -module(timer).  
2. -export([timeout/2,cancel/1,timer/3]).  
3. timeout(Time, Alarm) ->  
4.     spawn(timer, timer, [self(),Time,Alarm]).  
5. cancel(Timer) ->  
6.     Timer ! {self(),cancel}.  
7. timer(Pid, Time, Alarm) ->  
8.     receive  
9.      {Pid,cancel} ->  
10.        true  
11.     after Time ->  
12.         Pid ! Alarm  
13. end.  

   
5、註冊進程
    為了給進程發送訊息，我們需要知道進程的Pid，但是在某些情況下：在一個很大系統裡面有很多的全域servers，或者為了安全考慮需要隱藏進程 Pid。為了達到可以發送訊息給一個不知道Pid的進程的目的，我們提供了註冊進程的辦法，給進程們註冊名字，這些名字必須是atom。
    基本的調用形式：java 代碼

1. register(Name, Pid)  
2. 將Name與進程Pid聯絡起來  
3.   
4. unregister(Name)  
5. 取消Name與相應進程的對應關係。  
6.   
7. whereis(Name)  
8. 返回Name所關聯的進程的Pid，如果沒有進程與之關聯，就返回atom:undefined  
9.   
10. registered()  
11. 返回當前註冊的進程的名字列表  

6.進程的優先順序
設定進程的優先順序可以使用BIFs:
process_flag(priority, Pri)

Pri可以是normal、low,預設都是normal
優先順序高的進程將相對低的執行多一點。

7.進程組（process group)
    所有的ERLANG進程都有一個Pid與一個他們共有的稱為Group Leader相關聯，當一個新的進程被建立的時候將被加入同一個進程組。最初的系統進程的Group Leader就是它自身，因此它也是所有被建立進程及子進程的Group Leader。這就意味著Erlang的進程被組織為一棵Tree，其中的根節點就是第一個被建立的進程。下面的BIFs被用於操縱進程組：
group_leader()
返回執行進程的Group Leader的Pid
group_leader(Leader, Pid)
設定進程Pid的Group Leader為進程的Leader

8.Erlang的進程模型很容易去構建Client-Server的模型，書中有一節專門討論了這一點，著重強調了介面的設計以及抽象層次的隔離問題，不翻譯了。

轉載：http://hi.baidu.com/let163/blog/item/31ea79088dc27035b1351df0.html