Question

我是F＃的新手并尝试使用MailboxProcessor来确保状态更改是孤立完成的。

简而言之，我将动作（描述状态通道的不可变对象）发布到MailboxProcessor，在递归函数中我读取消息并生成新状态（即在下面的示例中将项添加到集合中）并发送陈述到下一次递归。

open System

type AppliationState =
    {
        Store : string list
    }
    static member Default = 
        {
            Store = List.empty
        }
    member this.HandleAction (action:obj) =
        match action with
        | :? string as a -> { this with Store = a :: this.Store }
        | _ -> this

type Agent<'T> = MailboxProcessor<'T>     

[<AbstractClass; Sealed>]
type AppHolder private () =
    static member private Processor = Agent.Start(fun inbox ->
        let rec loop (s : AppliationState) =
            async {
                let! action = inbox.Receive()
                let s' = s.HandleAction action
                Console.WriteLine("{s: " + s.Store.Length.ToString() + " s': " + s'.Store.Length.ToString())
                return! loop s'
                }
        loop AppliationState.Default)

    static member HandleAction (action:obj) =
        AppHolder.Processor.Post action

[<EntryPoint>]
let main argv =
    AppHolder.HandleAction "a"
    AppHolder.HandleAction "b"
    AppHolder.HandleAction "c"
    AppHolder.HandleAction "d"

    Console.ReadLine()
    0 // return an integer exit code

预期输出为：

s: 0 s': 1
s: 1 s': 2
s: 2 s': 3
s: 3 s': 4

我得到的是：

s: 0 s': 1
s: 0 s': 1
s: 0 s': 1
s: 0 s': 1

阅读MailboxProcessor的文档并在上面搜索我的结论是它是一个由“单线程”处理的消息队列，而不是看起来它们都是并行处理的。

我完全离开了这个领域吗？

Answer 1

问题是你认为gridMat = (np.linspace(1, 3, 100), np.linspace(0,2,100), np.linspace(5, 6,100)) mGrid = np.meshgrid(*gridMat, indexing = 'ij') values = np.power(mGrid[0], 2) + mGrid[1] / 4.0 + 3.0 + mGrid[2] * 4 @jit(nopython=True) def testFunction(values): idx = [] N = 3 for n in range(N): idx.append(n + 1) idx_res = tuple(idx) print(values[idx_res])每次都是同一个对象，但实际上每次都是一个不同的邮箱处理器。我将您的AppHolder代码更改为以下内容：

AppHolder.Processor

我做的唯一更改是简化Console.WriteLine调用以使用[<AbstractClass; Sealed>] type AppHolder private () = static member private Processor = printfn "Starting..." Agent.Start(fun inbox -> let rec loop (s : AppliationState) = async { let! action = inbox.Receive() let s' = s.HandleAction action printfn "{s: %A s': %A}" s s' return! loop s' } loop AppliationState.Default) static member HandleAction (action:obj) = AppHolder.Processor.Post action和printfn来获取更多调试详细信息，并添加将要执行的单个%A调用在构建和启动MailboxProcessor之前。我得到的输出是：

printfn "Starting..."

请注意，Starting... Starting... Starting... Starting... {s: {Store = [];} s': {Store = ["b"];}} {s: {Store = [];} s': {Store = ["d"];}} {s: {Store = [];} s': {Store = ["c"];}} {s: {Store = [];} s': {Store = ["a"];}}行已执行四次。

这会抓住很多F＃新手：printfn "Starting..."关键字定义属性，而不是字段。每次评估属性时，都会重新评估该属性的主体。因此，每次访问member时，都会获得一个新的MailboxProcessor。有关详细信息，请参阅https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/members/properties。

您可能想要的是以下内容：

AppHolder.Processor

Answer 2

我认为问题必须出在你的HandleAction实现中。我实现了以下内容，它产生了预期的输出。

open System

type ApplicationState =
    {
        Items: int list
    }
    static member Default = {Items = []}
    member this.HandleAction x = {this with Items = x::this.Items}

type Message = Add of int

let Processor = MailboxProcessor<Message>.Start(fun inbox ->
    let rec loop (s : ApplicationState) =
        async {
            let! (Add action) = inbox.Receive()
            let s' = s.HandleAction action
            Console.WriteLine("s: " + s.Items.Length.ToString() + " s': " + s'.Items.Length.ToString())
            return! loop s'
        }
    loop ApplicationState.Default)

Processor.Post (Add 1)
Processor.Post (Add 2)
Processor.Post (Add 3)
Processor.Post (Add 4)


// OUTPUT
// s: 0 s': 1
// s: 1 s': 2
// s: 2 s': 3
// s: 3 s': 4

修改

在看到更新的代码示例后，我相信正确的F＃解决方案只是将AppHolder类型从类转换为模块。更新的代码是这样的：

open System type AppliationState = { Store : string list } static member Default = { Store = List.empty } member this.HandleAction (action:obj) = match action with | :? string as a -> { this with Store = a :: this.Store } | _ -> this type Agent<'T> = MailboxProcessor<'T> module AppHolder = let private processor = Agent.Start(fun inbox -> let rec loop (s : AppliationState) = async { let! action = inbox.Receive() let s' = s.HandleAction action Console.WriteLine("{s: " + s.Store.Length.ToString() + " s': " + s'.Store.Length.ToString()) return! loop s' } loop AppliationState.Default) let handleAction (action:obj) = processor.Post action AppHolder.handleAction "a" AppHolder.handleAction "b" AppHolder.handleAction "c" AppHolder.handleAction "d"

这会输出与之前相同的结果：

{s: 0 s': 1 {s: 1 s': 2 {s: 2 s': 3 {s: 3 s': 4

F＃MailboxProcessor限制并行性

2 个答案: