教父的告白
一切都是纸老虎
posts - 82,  comments - 7,  trackbacks - 0
    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的模型,书中有一节专门讨论了这一点,着重强调了接口的设计以及抽象层次的隔离问题,不翻译了。
posted on 2009-09-11 10:12 暗夜教父 阅读(282) 评论(0)  编辑 收藏 引用 所属分类: erlang

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理



<2024年11月>
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

常用链接

留言簿(2)

随笔分类

随笔档案

文章分类

文章档案

搜索

  •  

最新评论

阅读排行榜

评论排行榜