BlueSea笔记<1>--Cricket初探

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

 type Say = | Hello

 let greeter =

     actor {

         name "greeter"

         body (

             let rec loop() = messageHandler {

                 let! msg = Message.receive()

                 match msg with

                 | Hello ->  printfn "Hello"

                 return! loop()

             }

             loop())

     } |> Actor.spawn

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

         member __.Body(ctx, behaviour) =

             { ctx with Behaviour = behaviour }

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

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

         member __.Bind(MH handler, f) =

              MH (fun context ->

                   async {

                      let! comp = handler context

                      let (MH nextComp) = f comp

                      return! nextComp context

                   }

              )

         member __.Bind(a:Async<_>, f) =

             MH (fun context ->

                 async {

                      let! comp = a

                      let (MH nextComp) = f comp

                      return! nextComp context

                   }

             )

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

Message.receive()的定义为：

     let receive() = MH (fun (ctx:ActorCell<_>) -> async {

         let! msg = ctx.Mailbox.Receive()

         ctx.Sender <- msg.Sender

         ctx.ParentId <- msg.Id

         ctx.SpanId <- Random.randomLong()

         traceReceive ctx

         return msg.Message

     })

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

      let rec loop() =

                // Message.receive()返回的MH-handler

                let msgHandlerReceive = MH (fun (ctx:ActorCell<_>) -> async {

                     let! msg = ctx.Mailbox.Receive()

                     ctx.Sender <- msg.Sender

                     ctx.ParentId <- msg.Id

                     ctx.SpanId <- Random.randomLong()

                     traceReceive ctx

                     return msg.Message

                 })

                 // 匹配msg并处理的代码块

                 let funCodeBlock = fun (msg:Say) ->

                     match msg with

                     | Hello ->  printfn "Hello"

                     let MH(leftCodeBlock) = loop()

                     // return! loop() => MessageHandler.ReturnFrom(loop())

                     MH(fun ctx ->

                         traceHandled ctx;

                         leftCodeBlock(ctx))

                 // let!中的处理，返回新的MH-handler(粘合receive和codeBlock，而codeBlock中会通过return!返回新的MH-handler由Async异步递归处理)

                 MessageHandler.Bind(msgHandlerReceive, fun codeBlock ->

                      MH (fun context ->

                           async {

                              let! comp = msgHandlerReceive context

                              let (MH nextComp) = codeBlock comp // 用户代码块返回新的MH-handler

                              return! nextComp context

                           }

                      ) )

注意上述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并执行流程。

巴特西

BlueSea笔记<1>--Cricket初探

最新文章

热门文章