数据竞赛?还是其他问题?

Question

今天才发现编程语言"pony"...并开始玩它。

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

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

由于这一切都是在我玩语言的第 1 小时，当然我可能会搞砸其他东西。

谁能解释我的错误？

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 [发布] 编译时间：LLVM 3.9.0 -- ?

Answer 1

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发送消息(请注意，由于两条消息没有相同的目标，因此仍然可以按任何顺序接收)。这意味着C发送到B的消息是在发送给BbyA的消息之后发送的，并且由于两者具有相同的目标，因此存在因果关系。

让我们看一下程序中的因果顺序。随着->"是原因"，我们有

• 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消息，然后在任何Producer开始执行它收到的消息并有机会发送tick消息之前发送query消息。如果你用一个调度程序线程运行你的程序(--ponythreads=1作为命令行参数)，它将始终打印produced: 0Main因为它将垄断唯一的调度程序，直到create结束。使用多个调度程序线程时，可能发生 0 到 10 之间的任何操作，因为所有调度程序都可能忙于执行其他参与者，或者可以立即开始执行Producer。

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

Answer 2

感谢 @Benoit Vey 的帮助。

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

从这个意义上说，没有巫毒教，没有魔法。这一切都只是表现得像任何演员系统应该表现的那样。

参与者中的消息按顺序处理(应该如此)。因此，为了获得所需的程序行为，生产者最终应该触发查询(在处理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 ()