scala - Akka 的 Actors 与 Erlang 的 Actors 中消息顺序语义的结果

Question

来自 Coursera 上的响应式编程原理类(class):

“如果一个 actor 向同一个目的地发送多条消息，它们将不会乱序到达(这是 Akka 特有的)。”

Actor A 和 B

A 向 B 发送 msg1A向B发送msg2

B会收到msg1然后msg2

警告:我从来没有用 Erlang 编程过

我相信在 Erlang 中不能保证这种消息排序语义。这似乎是一个巨大的差异，它会影响您可以使用本应相似的框架编写的不同类型的程序。

例如在 Akka 中你可以这样做:

case class msg(x: Int)
case object report
class B extends Actor {

var i: Int = 0
def recieve = {
    case msg(x) => i = i + x
    case report => sender ! i
 }
}

那么你可以做

A 发送 B 消息(5)

A 发送 B 消息(6)

A 发送 B 报告//保证总和为 11

我的主要观点是，Erlang 似乎无法保证返回的总和为 11。Erlang 是否不鼓励甚至禁止 Actors 包含任何可变状态？谁能详细说明在 Scala 的 Akka 与 Erlang 中可以和不能用 Actors 编写的不同类型的程序？

Answer 1

正如 Pascal 所说，两个进程之间的消息顺序是有保证的。在 Erlang 中，拥有一些“可变状态”的唯一方法是将它隐藏在 actor 后面。通常这样做:

loop(Sum) ->
    NewSum = receive Message of
        {msg, Number, Sender} -> add_and_reply(Sum, Number, Sender);
        _ -> Sum
    end,
    loop(NewSum).

add_and_reply(Sum, Number, Sender) ->
    NewSum = Sum + Number,
    Sender ! NewSum,
    NewSum.

这样，您就不会改变任何东西。您创建新状态并将其作为无休止递归的参数传递。运行循环的 Actor 确保所有调用都被一个接一个地处理，因为它一次只接受一条消息。

对我来说，Erlang 和 Akka 的主要区别在于抢占式调度。在 Erlang 中，您可以编写执行此操作的 actor:

loop(Foo) ->
    something_processor_consuming(),
    loop(Foo).

您的系统将正常工作。大多数通过库添加参与者的语言都会进入该线程，并且它将永远运行，阻止一个 CPU 内核执行。 Erlang 能够停止那个线程，运行其他的东西然后返回它，所以它运行得很好，即使你搞砸了。 Read more here .在 Erlang 中，您可以从 exit(Pid, kill) 外部终止进程，它会立即终止。在 Akka 中，它将继续处理直到它准备好接收下一条消息(您可以使用 trap_exit 标志在 Erlang 中模拟它)。

Erlang was built with fault tolerance and soft real time systems in mind从一开始，所以 OTP 强调监督流程。例如，在 Scala 中，supervisor 有机会在错误时恢复 child，而在 Erlang 中，child 在错误时崩溃并且必须重新启动。这是因为假设，崩溃意味着糟糕的状态，我们不想传播它。