标签: actor-model

我一直在努力了解演员模型和网络工作者是如何工作的。

在https://dzone.com/articles/html5-web-workers-classic 中：“Web Workers 提供了一个消息传递模型，其中脚本只能通过明确定义的不可变消息进行通信，不共享任何数据，并且不使用同步机制来保证信号或数据完整性。”

对我来说，这听起来与演员模型非常相似。有区别吗？

更新：根据 Benjamin Erb 的说法：

"actor 模型的基本思想是将actor 用作并发原语，可以以不同的方式对接收消息进行操作：

1.向其他参与者发送有限数量的消息。
2. 产生有限数量的新演员。
3. 改变自己的内部行为，在处理下一个传入消息时生效。”

前两个适用，但最后一个怎么样？

我是斯卡拉和演员界的新人.

这是我到目前为止所学到的:

Scala是函数式编程(不是纯粹的),人们建议不要在scala中使用可变状态.

但另一方面,有一个实现actor模型的akka​​框架.在玩akka期间,我意识到消息是不可变的,但是MUTABLE中的演员状态.所以,我需要在actor中指定"var"变量和可变集合.并且,对我来说,拥有一个可变状态对于scala来说并不自然.

那么,我的理解是否正确？为什么人们在不变的scala语言中采用了可变的actor模型？

我想和 python 中的演员一起玩。显然，两个最受欢迎的替代品是thespian和pykka。我正在寻找积极开发且易于使用的东西。

您会推荐哪一个，为什么？

我已经看到了Actor模型实现的基准测试.例如,Akka actor非常轻量级(每个actor 600个字节),并且可以创建数百万个.但是,我从未在消息传递吞吐量方面看到过基准测试.

例如,给定一些演员,每秒之间可以传递多少条消息？

有没有人有这样一个性能基准的链接(在消息传递吞吐量方面)？

我寻找 JoinBlock 的替代方案，它可以通过 n-TransformBlocks 链接，并将所有 TransformBlock 源块的消息连接/合并在一起，以便将此类的集合传递给另一个数据流块。

JoinBlock 可以很好地完成工作，但仅限于连接 3 个源块。它还存在许多效率低下的问题（连接 2 个源块的偶数值类型（整数）非常慢）。有没有办法让任务从 TransformBlocks 返回并等到所有 TransformBlocks 都有一个完成的任务才能接受Task<item>？

任何替代想法？我可能有 1-20 个这样的转换块，在传递连接的项目集合之前，我需要将哪些项目连接在一起。每个转换块都保证为每个“转换”的输入项准确返回一个输出项。

编辑：要求澄清：

根据我之前的一个问题，我按如下方式设置了我的 JoinBlock：

public Test()
{
    broadCastBlock = new BroadcastBlock<int>(i =>
        {
            return i;
        });

    transformBlock1 = new TransformBlock<int, int>(i =>
        {
            return i;
        });

    transformBlock2 = new TransformBlock<int, int>(i =>
        {
            return i;
        });

    joinBlock = new JoinBlock<int, int>();

    processorBlock = new ActionBlock<Tuple<int, int>>(tuple =>
        {
            //Console.WriteLine("tfb1: " + tuple.Item1 + "tfb2: " + tuple.Item2);
        });

    //Linking …

我正在研究F#Akka.Net API,它与C#对应物完全不同,因为它试图以惯用的方式公开Akka功能.所以它引入了一个计算表达式actor和几个辅助函数actorOf和actorOf2:

let consoleWriterActor = 
        spawn myActorSystem "consoleWriterActor" (actorOf Actors.consoleWriterActor)
let consoleReaderActor = 
        spawn myActorSystem "consoleReaderActor" (actorOf2 (Actors.consoleReaderActor consoleWriterActor))

所述actorOf是有用产卵不依赖于额外的行动者演员,和actorOf2允许发送另一个演员作为正在创建的演员的参数,如上所示.

这很清楚,但我想知道将一个演员作为参数是多么特别？不定义actorOf3,actorOf4等有助于将多个actor参数发送给正在创建的actor吗？例如,C#generic Action <...>宏具有最多16个操作参数的定义.定义几个actorOfX函数是否有意义？例如,使用验证操作的Akka.Net bootcamp代码如下所示:

let consoleWriterActor = 
    spawn myActorSystem "consoleWriterActor" (actorOf Actors.consoleWriterActor)
let validationActor = 
    spawn myActorSystem "validationActor" (actorOf2 (Actors.validationActor consoleWriterActor))
let consoleReaderActor = 
    spawn myActorSystem "consoleReaderActor" (actorOf2 (Actors.consoleReaderActor validationActor))

您可以看到actor在链中相互引用:consoleReaderActor引用validationActor和validationActor引用consoleWriterActor.但是如果我想让consoleReaderActor同时引用validationActor和consoleWriterActor呢？使用actorOf函数看起来不太可能.

更新感谢@Horusiath的回答.我查看了Akka.Net bootcamp(F#版本)中的一个课程,实际上可以在生成一个新的actor时指定多个actor:

let a1 = 
    spawn myActorSystem "a1" …

我知道Erlang使用Actor模型来支持并发,而Erlang进程与Actors相同:它们发送消息,不可变等等.但根据Carl Hewitt的说法,Actor模型中的一个重要事项是非决定性和仲裁(给定仲裁者,你可以同时将多个输入(例如I0和I1)输入仲裁器,但只有一个可能的结果(例如O0)或O1)将在另一端出来).

所以,我很有意思,Erlang如何实现这个概念？Arbiters在Erlang并发模型/ actor模型实现中的作用是什么？

我有使用诸如RabbitMQ和其他消息传递技术的企业分布式系统的背景，尽管我对Actor Model.

话虽如此，我想知道使用Actor Model诸如AKKA或AKKA.NET类似的应用程序的框架是否是个好主意Whatsapp？鉴于此类应用程序的要求（高可用性、低延迟等...）。

我的另一个问题是，Erlang 的内置 actor 模型是大公司将其用于其消息传递应用程序的原因还是我不知道的其他原因？

技术解释受到高度赞赏。提前致谢。

我是Scala Actors的新手.我打算构建的应用程序有几个盒式磁带,每个盒式磁带都执行特定的http调用,并定期检索+持久保存一些信息.稳健性是最重要的.到目前为止,这些是我想到的方式:

1. 围绕TimerTask构建应用程序,从Actor扩展盒式磁带并.act定期调用它们(或者我应该发送它们消息？有什么区别？)
2. 从Actor扩展并使用Timeouts定期运行它们.

有人可以对这些差异有所了解吗？

我\xe2\x80\x99 已经研究 actor 模型有一段时间了，并试图找出如何将其与 RESTful API 正确结合。我\xe2\x80\x99m正在努力如何通过使用ask-pattern或actor-per-request来分离两层的职责。对于这两种模式，请求-回复语义都会泄漏到参与者模型中，这看起来像是一种反模式。大多数由 HTTP 请求发起、发送给参与者的消息都需要回复。接收参与者有多个条件，需要向 API 发出它无法满足请求的信号。

此外，在输入验证方面什么被认为是良好实践；是否应该将其作为 HTTP 的一部分来实现（例如，如果字段 X 是有效的电子邮件地址，如果字段 Y 包含整数）。对于复杂的域逻辑，当（前置）条件失败时，参与者如何/应该通知发送者？

所以我只最近遇到一个玩具容量的阿卡之外,我不禁注意到它和OTP尽管Scala的静态类型的一般优先股动态类型.我开始挖掘一下,并且遇到了这篇描述HM型系统而非erlang进程间通信的Wadler论文.也就是说,SO的这个问题的答案是指Wadler和Marlow未能提供他们对过程类型通信的草图.作为参考,我对这样的代码感到非常失望:

def receive = {
    case "test" => log.info("received test")
    case _ => log.info("received unknown message")
  }

我知道在实践中,透析器可以提供真实类型系统的大量好处,但为什么创建静态验证的演员系统这么困难呢？当我们使用类型系统时,我们是倾向于编写Future或Observable/ Iteratee库,或者是Channel编程的IO而不是演员系统,还是Wadler和Marlow错过了技术难度？

我从演员模型开始，在理解这个概念时遇到了一些问题，请用示例简单地解释一下。