博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
BlueSea笔记<1>--Cricket初探
阅读量:5849 次
发布时间:2019-06-19

本文共 4277 字,大约阅读时间需要 14 分钟。

    最近在看Cricket这个实现了Actor模式的F#开源框架,对其工作方式作了一番探究。首先来看一段简单的例子代码:

1 type Say = | Hello 2 let greeter =  3     actor { 4         name "greeter" 5         body ( 6             let rec loop() = messageHandler { 7                 let! msg = Message.receive() 9                 match msg with10                 | Hello ->  printfn "Hello"11 12                 return! loop()13             }14             loop())15     } |> Actor.spawn

    先是定义了消息类型Say,接着通过computation-expression(计算表达式)的方式定义了greeter这个actor。actor计算表达式的定义见ActorConfigurationBuilder,包括body、name等都通过CustomOperationAttribute的方式给出了定义。比如body:

1         member __.Body(ctx, behaviour) = 2             { ctx with Behaviour = behaviour }

    这里的behaviour即是上述例子中"body语法字"括号中的代码块。它构建了新的ctx:ActorConfiguration<'a>,即这里的ActorConfiguration<Say>。可以预见,behaviour作为一个被缓存的行为,必定在将来一个合适的时机被调度执行。在这之前,还是先看下代码块中的具体执行内容。

    messageHandler又是一个计算表达式,定义在MessageHandlerBuilder中。这里主要是看下let!与return!的定义。先看let!:

1         member __.Bind(MH handler, f) = 2              MH (fun context ->  3                   async { 4                      let! comp = handler context 5                      let (MH nextComp) = f comp 6                      return! nextComp context 7                   }  8              )  9         member __.Bind(a:Async<_>, f) = 10             MH (fun context -> 11                 async {12                      let! comp = a13                      let (MH nextComp) = f comp14                      return! nextComp context15                   } 16             )

    这里MH的定义为:type MessageHandler<'a, 'b> = MH of ('a -> Async<'b>)。这里需要反复强调的是,async声明只是被转换为Async.Bind()这种形式的函数调用,并不代表任何对象。至于返回Async<'b>,那是因为Async.Bind()函数本身返回Async<'b>对象,即AsyncBuilder加工处理的中间对象。不止async,任何计算表达式都是如此。

    Message.receive()的定义为:

1     let receive() = MH (fun (ctx:ActorCell<_>) -> async {2         let! msg = ctx.Mailbox.Receive()3         ctx.Sender <- msg.Sender4         ctx.ParentId <- msg.Id5         ctx.SpanId <- Random.randomLong()6         traceReceive ctx7         return msg.Message  8     })

    由Bind的定义可以看到,它包装了参数handler并返回新的MH-handler。我开始一直认为,Bind函数中会解析从Message.receive()的返回值,并交给后续代码块处理。但是这里却是返回了一个新的MH-handler,令人百思不得其解。事实上这依然是一个缓存的行为。我们可以把代码展开:

1      let rec loop() = 2                // Message.receive()返回的MH-handler  3                let msgHandlerReceive = MH (fun (ctx:ActorCell<_>) -> async { 4                     let! msg = ctx.Mailbox.Receive() 5                     ctx.Sender <- msg.Sender 6                     ctx.ParentId <- msg.Id 7                     ctx.SpanId <- Random.randomLong() 8                     traceReceive ctx 9                     return msg.Message  10                 })11                 // 匹配msg并处理的代码块12                 let funCodeBlock = fun (msg:Say) ->13                     match msg with14                     | Hello ->  printfn "Hello"15 16                     let MH(leftCodeBlock) = loop()            17                     // return! loop() => MessageHandler.ReturnFrom(loop())18                     MH(fun ctx ->19                         traceHandled ctx;20                         leftCodeBlock(ctx))21                     22                 // let!中的处理,返回新的MH-handler(粘合receive和codeBlock,而codeBlock中会通过return!返回新的MH-handler由Async异步递归处理)23                 MessageHandler.Bind(msgHandlerReceive, fun codeBlock ->24                      MH (fun context -> 25                           async {26                              let! comp = msgHandlerReceive context27                              let (MH nextComp) = codeBlock comp // 用户代码块返回新的MH-handler28                              return! nextComp context29                           }30                      ) )

    注意上述MessageHandler.Bind调用时传入的codeBlock即为funCodeBlock,也就是用户代码。这里可以清楚地看到loop()事实上是通过嵌套调用MessageHandler.Bind(各种do!和let!以及return!)构建返回了一个个新的MH-handler,将message接收、解析、用户代码处理等串联起来,当调用loop()时(也就是将来调用ActorConfiguration<Say>.Behaviour时)返回一个串联后的MH-handler,再在合适的时机加以执行。至此,整个流程已经清楚,剩下的就是搞清楚何时执行behaviour的问题了。在构建ActorConfiguration<Say>结束后将由Actor.spawn处理,会创建Actor对象,并在创建中通过Async.Start执行如下代码:

do! MessageHandler.toAsync ctx defn.Behaviour

    这里defn.Behaviour即是当初串联而来的MH-handler,ctx即为ActorCell<Say>。再看下MessageHandler.toAsync就一目了然了:

let toAsync ctx (MH handler) = handler ctx |> Async.Ignore

    接收ActorCell<Say>对象ctx并执行流程。

转载于:https://www.cnblogs.com/Jackie-Snow/p/6242006.html

你可能感兴趣的文章
windows2008支持多用户同时登录
查看>>
UEditor 1.2.5 for java 自定义配置
查看>>
从Redis的数据丢失说起
查看>>
理解对象(通过关联数组和基本包装类型)
查看>>
linux查看系统版本(32位/64位)的方法
查看>>
Highcharts中Legend动态显示点值
查看>>
MySQL数据库主从同步(单台2实例)
查看>>
HashMap和HashTable简介和区别
查看>>
java json 库之 jackson
查看>>
【图像缩放】最邻近插值
查看>>
阿里数据中台七年演化史——行在口述干货
查看>>
10.Java异常问题
查看>>
利用Git Webhooks实现jekyll博客自动化部署
查看>>
Fescar undoExecutor介绍
查看>>
Linux命令操作大全
查看>>
从周五开始香港主机特别慢,香港主机用户有同感吗?
查看>>
Ember.js 3.9.0-beta.3 发布,JavaScript Web 应用开发框架
查看>>
python标准库00 学习准备
查看>>
4.2. PHP crypt()
查看>>
commonservice-config配置服务搭建
查看>>