5

今天才发现编程语言“小马”……并开始使用它。

我的代码应该做一些简单的生产者消费者事情。正如语言文档所声称的那样，该语言确保没有数据竞争。

在这里，main 向生产者发送了 10 条消息，生产者又向消费者发送了 10 条消息。消费者增加一个计数器状态变量。然后，main 向消费者发送一条消息，消费者又向 main 发送一条消息以显示当前值。如果所有消息都按顺序排列，则预期值为 9（或 10）。打印的结果是 0。

因为这是我玩语言的第一个小时，当然我可能搞砸了别的东西。

谁能解释我的错误？

use "collections"

actor Consumer 
    var _received : I32
    new create() =>
        _received = 0
    be tick() =>
        _received = _received + 1
    be query(main : Main) =>
        main.status(_received)

actor Producer
    var _consumer : Consumer
    new create(consumer' : Consumer) =>
        _consumer = consumer'

    be produceOne () =>
        _consumer.tick()

actor Main
    var _env : Env 
    new create(env: Env) =>
        _env = env
        let c : Consumer = Consumer.create()
        let p = Producer.create(c)
        for i in Range[I32](0,10) do
            p.produceOne()
        end
        c.query(this)

    be status( count : I32) =>
        // let fortyTwo : I32 = 42
        // _env.out.print( "fortytwo? " + (fortyTwo.string()))
        _env.out.print( "produced: " + (count.string()) )

顺便说一句，在 Windows 10、64 位上运行。使用我发现的最新最好的 zip 文件安装。

0.10.0-1c33065 [release] 编译为：llvm 3.9.0 -- ?

4

2 回答 2

6

Pony 阻止的数据竞争是在内存级别发生的，当有人从内存位置读取而其他人正在写入时。这可以通过禁止与类型系统共享可变状态来防止。

但是，如果结果取决于 Pony 不保证的消息顺序，您的程序仍然可能存在“逻辑”数据竞争。Pony 保证消息的因果顺序。这意味着如果消息具有相同的目的地，则发送或接收的消息是将来发送或接收的任何消息的原因，当然原因必须在其影响之前发生。

actor A
  be ma(b: B, c: C) =>
    b.mb()
    c.mc(b)

actor B
  be mb() =>
    None

actor C
  be mc(b: B) =>
    b.mb()

在此示例中，B将始终在消息来自A之前接收消息，C因为在A发送消息到B之前发送消息到C（请注意，由于它们没有相同的目的地，仍然可以以任何顺序接收两条消息）。这意味着发送到的消息B是C在发送到的消息之后发送的B，A并且由于两者具有相同的目的地，因此存在因果关系。

让我们看看程序中的因果顺序。有了->“是原因”，我们有

  • Main.create -> Main.status（通过Consumer.query）
  • Consumer.create -> Consumer.query
  • Consumer.create -> Consumer.tick（通过Producer.produceOne）
  • Producer.create -> Producer.produceOne

Consumer.query如您所见，和之间没有因果关系Consumer.tick。在实际实现的意义上，这意味着Main可以发送produceOne消息，然后query在任何Producer开始执行它收到的消息并有机会发送消息之前发送tick消息。如果您使用一个调度程序线程（--ponythreads=1作为命令行参数）运行程序，它将始终打印produced: 0，因为Main它将垄断唯一的调度程序直到create. 对于多个调度程序线程，0 到 10 之间的任何事情都可能发生，因为所有调度程序都可能忙于执行其他参与者，或者可以Producer立即开始执行 s。

总之，您的tick行为query可以按任何特定顺序执行。要解决此问题，您必须在消息之间引入因果关系，方法是添加往返消息或在同一个参与者中进行累积和打印。

于 2017-03-16T06:38:55.617 回答
2

感谢@Benoit Vey 提供的帮助。

确实如此，在查询的执行与生产者向消费者执行其 tick() 消息传递的时间之间没有明示或暗示的偶然性。

从这个意义上说，没有巫毒，没有魔法。这一切都表现得像任何参与者系统所期望的那样。

Actor 中的消息按顺序处理（应该如此）。因此，为了获得所需的程序行为，生产者应该最终触发查询（按照处理produceOne消息后的顺序）。

在这里，如何实现：

use "collections"

actor Consumer 
    var _received : I32
    new create() =>
        _received = 0
    be tick() =>
        _received = _received + 1
    be query(main : Main) =>
        main.status(_received)

actor Producer
    var _consumer : Consumer
    new create(consumer' : Consumer) =>
        _consumer = consumer'

    be produceOne () =>
        _consumer.tick()

    be forward (main : Main) =>
        main.doQuery(_consumer)

actor Main
    var _env : Env 
    new create(env: Env) =>
        _env = env
        let c : Consumer = Consumer.create()
        let p = Producer.create(c)
        for i in Range[I32](0,10) do
            p.produceOne()
        end
        //c.query(this)
        p.forward(this)

    be doQuery (target : Consumer) =>
        target.query(this)

    be status( count : I32) =>
        // let fortyTwo : I32 = 42
        // _env.out.print( "fortytwo? " + (fortyTwo.string()))
        _env.out.print( "produced: " + (count.string()) )

只是为了咯咯笑（和比较），我也在 F# 中实现了相同的功能。令我惊讶的是，小马在紧凑性类别中获胜。Pony 中 39 行代码，F# 中 80 行。再加上原生代码生成，Pony 确实是一个有趣的语言选择。 

open FSharp.Control

type ConsumerMessage =
    | Tick
    | Query of MailboxProcessor<MainMessage>

and ProducerMessage =
    | ProduceOne of MailboxProcessor<ConsumerMessage>
    | Forward of (MailboxProcessor<MainMessage> * MainMessage)

and MainMessage =
    | Status of int
    | DoQuery of MailboxProcessor<ConsumerMessage>

let consumer = 
    new MailboxProcessor<ConsumerMessage>
        (fun inbox ->
            let rec loop count =
                async {
                    let! m = inbox.Receive()
                    match m with
                    | Tick ->
                        return! loop (count+1)
                    | Query(target) ->
                        do target.Post(Status count)
                        return! loop count
                }        
            loop 0
        )

let producer =
    new MailboxProcessor<ProducerMessage>
        (fun inbox ->
            let rec loop () =
                async {
                    let! m = inbox.Receive()
                    match m with
                    | ProduceOne(consumer') ->
                        consumer'.Post(Tick)
                        return! loop ()
                    | Forward (target, msg) ->
                        target.Post(msg)
                        return! loop ()
                }
            loop ()
        )

let main =
    new MailboxProcessor<MainMessage>
        (fun inbox ->
            let rec loop () =
                async {
                    let! m = inbox.Receive()
                    match m with
                    | Status(count) ->
                        printfn "Status: %d" count
                        return! loop ()
                    | DoQuery(target) ->
                        target.Post(Query inbox)
                        return! loop ()
                }
            loop ()
        )

let init() =
    main.Start()
    consumer.Start()
    producer.Start()

let run() =
    for _ in [1..10] do
        producer.Post(ProduceOne consumer)
    producer.Post(Forward(main,DoQuery consumer))

let query () = 
    consumer.Post(Query main)

let go() =
    init ()
    run ()
    //query ()
于 2017-03-16T12:09:00.860 回答