3

我一直在慢慢研究 F# 带来的所有功能。一个特别引起我兴趣的是MailboxProcessor.

  1. C# 中的等价物很可能会使用锁。我们可以考虑MailboxProcessor作为锁的替代品吗？
  2. 在下面的示例中，我是否在做任何特别幼稚的事情，或者您能看到任何可以改进的地方吗？


module Tcp =
    open System
    open System.Collections.Generic
    open System.Net
    open System.Net.Sockets
    open System.Threading    

    type SocketAsyncMessage =
        | Get of AsyncReplyChannel<SocketAsyncEventArgs>
        | Put of SocketAsyncEventArgs
        | Dispose of AsyncReplyChannel<MailboxProcessor<SocketAsyncMessage>>

    type SocketAsyncEventArgsPool(size:int) =             
        let agent = 
            lazy(MailboxProcessor.Start(
                    (fun inbox ->
                        let references = lazy(new List<SocketAsyncEventArgs>(size))       
                        let idleReferences = lazy(new Queue<SocketAsyncEventArgs>(size))                    
                        let rec loop () = 
                            async {
                                let! message = inbox.Receive()
                                match message with
                                | Get channel -> 
                                    if idleReferences.Value.Count > 0 then
                                        channel.Reply(idleReferences.Value.Dequeue())
                                    else    
                                        let args = new SocketAsyncEventArgs()
                                        references.Value.Add args
                                        channel.Reply args  
                                    return! loop()
                                | Put args ->
                                    if args = null then
                                        nullArg "args" 
                                    elif references.Value.Count < size then
                                        idleReferences.Value.Enqueue args
                                    else                                       
                                        if not(references.Value.Remove args) then
                                            invalidOp "Reference not found."                                        
                                        args.Dispose() 
                                    return! loop()
                                | Dispose channel ->
                                    if references.IsValueCreated then
                                        references.Value 
                                        |> Seq.iter(fun args -> args.Dispose())
                                    channel.Reply inbox 
                            }
                        loop())))

        /// Returns a SocketAsyncEventArgs instance from the pool.         
        member this.Get () =
            agent.Value.PostAndReply(fun channel -> Get channel)            
        /// Returns the SocketAsyncEventArgs instance to the pool. 
        member this.Put args =
            agent.Value.Post(Put args)
        /// Releases all resources used by the SocketAsyncEventArgsPool.
        member this.Dispose () =
            (this:>IDisposable).Dispose()  

        interface IDisposable with
             member this.Dispose() =
                if agent.IsValueCreated then
                    (agent.Value.PostAndReply(fun channel -> Dispose channel):>IDisposable).Dispose()
4

2 回答 2

6

邮箱（和类似的结构）用于不使用锁的编程模型中，因为它们本质上是围绕异步处理构建的。（缺乏共享可变状态是该模型的另一个要求）。

Actor 模型可以被认为是一系列单线程迷你应用程序，它们通过相互发送和接收数据进行通信。每个迷你应用程序一次只能由一个线程运行。这与缺乏共享状态相结合，使得锁变得不必要。

过程模型（大多数 OO 代码本质上是过程模型）使用线程级并发和对其他对象的同步调用。Actor 模型对此进行了翻转——对象之间的调用（消息）是异步的，但每个对象都是完全同步的。

坦率地说，我不知道足够的 F# 来真正分析您的代码。看起来您确实想在邮箱周围贴上一个看起来同步的外壳，我想知道这是否真的是最好的事情（与完全采用邮箱模型相比）。在您的实现中，您似乎正在使用它来替代锁。

于 2010-02-08T06:19:08.080 回答
0

对于您问题的第一部分：

MailboxProcessor 类是在自己的线程上运行的消息队列。您可以从任何线程异步或同步地向 MailboxProcessor 发送消息。

这种模型允许通过消息传递而不是使用锁/互斥体/ipc机制在线程之间进行通信。

于 2010-02-08T06:31:49.490 回答