Erlang并发编程2

原文：http://erlang.group.iteye.com/group/wiki/1442-programming-erlang-reading-notes-8-concurrency-programming

自定义让当前进程sleep T毫秒的方法 

Java代码  

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

自定义Timer 

Java代码  

1. -module(stimer).  
2. -export([start/2, cancel/1]).  
3.   
4. start(Time, Fun) -> spawn(fun() -> timer(Time, Fun) end).  
5.   
6. cancel(Pid) -> Pid ! cancel.  
7.   
8. timer(Time, Fun) ->  
9.   receive  
10.     cancel ->  
11.       void  
12.   after Time ->  
13.       Fun()  
14.   end.  

每个进程都有一个mailbox 
发送消息到该进程时，消息被放入mailbox 
当程序运行到receive语句时，启动一个timer 
读取mailbox中的第一条消息，匹配Pattern1，2，...，如果消息匹配了，则从mailbox中删除掉，并执行该Pattern后的表达式 
如果receive语句中没有匹配的Pattern，则将该消息从mailbox中删除并放入save queue，然后下一条消息进来匹配 
如果mailbox中没有一条消息是匹配成功的，则进程suspend并等待下一次新的消息进来，下次有新消息时save queue里的消息不会再匹配 
一旦有消息匹配，则已经放入save queue的消息按到达进程的顺序重新进入mailbox，如果设置了timer，则清空save queue 
如果在等待消息时timer到点，则执行ExpressionsTimeout表达式并将保存的消息按到达进程的顺序放入mailbox 

publishing一个process identifier，这样系统里所有process都可以和这个process交互，发布的process称为registered process 
BIFs: 

Java代码  

1. register(AnAtom, Pid)  
2. unregister(AnAtom)  
3. whereis(AnAtom) -> Pid | undefined  
4. registered() -> [AnAtom::atom()]  

Example 

Java代码  

1. 1> Pid = spawn(fun area_server:loop/0).  
2. <0.51.0>  
3. 2> register(area, Pid).  
4. true  
5. 3> area ! {rectangle, 4, 5}.  
6. Area of rectangle is 20  
7. {rectangle,4,5}  

Example2 

Java代码  

1. -module(clock).  
2. -export([start/2, stop/0]).  
3.   
4. start(Time, Fun) ->  
5.   register(clock, spawn(fun() -> tick(Time, Fun) end)).  
6.   
7. stop() -> clock ! stop.  
8.   
9. tick(Time, Fun) ->  
10.   receive  
11.     stop ->  
12.       void  
13.   after Time ->  
14.     Fun(),  
15.     tick(Time, Fun)  
16.   end.  
17.   
18. %%%%%%%%%%%%%%%%%%  
19. 1> clock:start(5000, fun() -> io:format("TICK ~p~n", [erlang:now()]) end).  
20. 2> clock:stop().  

Concurrent Program Template 

Java代码  

1. -module(ctemplate).  
2. -compile(export_all).  
3.   
4. start() ->  
5.   spawn(fun() -> loop([]) end).  
6.   
7. rpc(Pid, Request) ->  
8.   Pid ! {self(), Request},  
9.   receive  
10.     {Pid, Response} ->  
11.       Response  
12.   end.  
13.   
14. loop(X) ->  
15.   receive  
16.     Any ->  
17.       io:format("Received:~p~n", [Any]),  
18.       loop(X)  
19.   end.  

在loop里receive之后马上又调用loop，则loop称为tail-recursive方法 
如果我们写一个方法F，F never returns，则需要确保在调用F之后不会调用其他方法，也不要将F用于List或Tuple的constructor，否则内存溢出 

spawn with MFA: 

Java代码  

1. spawn(Mod, FuncName, Args)  

使用Mod名、Func名和Args列表(成为一个MFA)来显式的调用spawn是确保系统动态加载代码(热修改)的正确方式
spawn with funs则不会动态加载代码