我正在阅读Akka文档，我不明白主机如何等待结果消息 在代码底部，主机收到一条Calculate消息 // start the calculation master ! Calculate 但是消息是一条告诉消息，这意味着它是异步的。为什么应用程序在那一行之后不退出？我相信AkkaActorSystem的默认调度程序使用守护进程线程，因此JVM不会退出，除非关闭ActorSystem。这就是为什么测试将继续运行，即使tell是App的最后一行 因此，让它等待的是JVM特性，而不是框架……你知道

我有一个方法getAggOutput（），它在Actor a中返回一个HashMap def getAggOutput: HashMap[X, List[Y]] = { println("***** Inside getAggOutput, rMap is: " + rMap) return rMap } 此外，在Actor A中，在case对象GETOUTPUT下调用该方法： case GETOUTPUT => println("***** Inside GET

我们正在用肉桂和格拉法纳监控演员。有时ShardRegion演员的邮箱会越来越大，我们不明白为什么。我想阅读ShardRegions邮箱中的邮件并找出问题所在。在以前的akka版本中，我们可以使用以下代码仅获取邮箱的大小： getContext().getMailboxSize(); 有没有办法获取邮箱中的邮件类型？Stack Overflow是一个编程问答网站，这听起来不像是一个编程问题。我想你对akka和actor一无所知，所以让其他人来回答这个问题。仅供参考，要查看actor邮箱的内容，

我做了一些尽职调查，甚至深入研究了Akka代码，但不明白为什么我的节点会通过kubernetes api被发现，一个节点自连接，提升到leader，但另一个由于leader无法解析请求者的地址而无法加入集群。我将分别发布应用程序配置和日志 这是一个2节点（目前）Akka集群，使用Akka管理和Akka发现，使用kubernetes api发现2个吊舱中的节点。我正在使用一个自定义标签选择器“application=vcsvc，environment=multibox，akka cluster=v

我有一些Akka 1.3代码，用于处理与外部消息传递系统的集成，该系统不直接支持回复的概念。我试图将代码库升级到Akka 2.0，但遇到了麻烦，因为我现有的设计依赖于模拟“回复”机制，将密钥生成到ConcurrentHashMap中，并使用senderFuture进行清理 发送给处理调度的参与者的消息可能会或可能不会期望得到回复，即使它们期望得到回复，在通过网络发送后，它们也可能永远得不到回复。因此，HashMap应该只存储实际需要回复（询问，而不是告知）的消息的条目，并且它必须具有某种形式的清

我正在尝试创建一个路由器，它将使用构造函数arg（一种变异方法）部署参与者 object LocalRouterArgEvalFrequency { def main(args: Array[String]) { val system = ActorSystem("TestSystem") var number = 0 def getANumber: Int = { number += 1 number } val rout

我一点阿克卡经验都没有。我想知道Akka消息在JVM内以及JVM之间是如何工作的 JVM中的消息是否是一些类似POJO的对象 JVM之间的通信是否需要类似JMS的服务器 Akka如何抽象这两种消息之间的差异 是否需要序列化 我可以使用其他一些协议（例如JMS、SOAP等）进行JVM间的通信吗？例如，Spring集成或Apache Camel可以处理任何类型的通信协议 文档中有关远程处理的部分回答了大部分问题： JVM中的消息是您想要的任何消息，只要它们是不可变的 除了两个ActorSyst

应用程序依赖项包括： com.typesafe.akka#akka-actor_2.10;2.3.7 org.reactivemongo#reactivemongo_2.10:0.10.5.0.akka23 org.reactivemongo#play2-reactivemongo_2.10:0.10.5.0.akka23 和两个spray LIB，所有版本均为1.3.1 当启动应用程序时，我得到 java.lang.AbstractMethodError at akka.actor.

我在做一个基于Akka持久FSM的项目。特别是： 我想知道构建独立性测试用例的最佳方法是什么？由于状态更改是持久化的（文档中没有很好地解释这一点，但可以看到），因此要确保持久化的参与者始终以干净的状态开始，这可能会很棘手。是否需要手动将重置构建到我的actor FSM协议中？如果是这样的话，这似乎并不理想，因为这是一种新的行为，需要用户自己进行测试 在测试中管理日志本身的最佳方法是什么？有没有一种简单的方法可以配置使用不同的日志进行测试，而不必在actor设计本身中明确地进行选择？文档部分提到手

我试图用Akka-Http和Akka-Stream实现一个透明代理 但是，我遇到了一个问题，Akka Http从上游服务器上传并解析响应头 例如，当上游服务器发送以下标头时： 过期：“0” Akka会将其解析为Expires标头，并将值更正为： 到期：“星期三，1月1日1800:00:00 GMT” 虽然unix时间的开始比“0”好，但我不希望此代理触及任何标题。我希望代理是透明的，而不是“修复”任何通过的头 以下是简单的代理： Http（）.bind（“localhost”，9000）.to（

在阿克卡溪流中，Mat In Source[输出，Mat]或Sink[输入，Mat]代表什么。何时实际使用它？类型参数表示此流的物化值的类型 请记住，在Akka源代码中，流代码中，汇代码中（好吧，所有图形）都只是蓝图-它们自己不做任何处理，它们只描述流应该如何构造。将这些蓝图转化为具有实时数据的工作流的过程称为物化 具体化流的核心方法称为run（），它位于RunnableGraph类中。运行流的所有其他方法（例如接收器上的运行方式或源）最终委托给此方法。您可以看到此方法返回Mat。也就是说，物化

我有15个应用程序在一台主机的容器中运行。我的应用程序使用基于它检测到的CPU数量的默认线程池大小，这是主机正在公开的（16），但是我为每个应用程序分配1个CPU（使用mesos）。我知道这些只是CPU共享，而不是完整的CPU，但我不认为我的应用程序应该配置为CPU相关设置的默认值（我已经定义了每个jvm的最大内存） AKKA线程池执行器中的并行度因子parallelism max的正确值是什么 感谢并行度系数由并行度最大值（和并行度最小值）限制，基本上是最大值（并行度最小值，最小值（并行度最大

有人为Akka Actor系统设置typesafe控制台吗？我一直在尝试为actor系统设置typesafe控制台，但它总是显示错误。我这样做了。请参阅我的，包括所需的七个步骤。FWIW，Typesafe的任务是让开发人员更容易地完成这个过程，我们正专注于此。我们的目标是使其与Activator过程一样简单（下载一个简单的ZIP文件，展开并运行）。感谢分享项目详细信息，您能告诉我您将atmos.conf放在了什么地方吗？

我试图构建一个两节点的akka集群，两个节点都配置为种子节点。在每个节点上，我创建actor并通过以下方式定位它： akka { //loglevel = "DEBUG" log-config-on-start = on actor { provider = "akka.cluster.ClusterActorRefProvider" } remote { log-remote-lifecycle-events = off netty.tcp

直接从Akka文档第2.5.5节（“重用参与者路径”）开始： 当一个参与者被终止时，它的引用将指向死信邮箱，死亡之翼将发布它的最终转换，一般来说，它不会再次恢复生命（因为参与者生命周期不允许这样） 我想知道这个DeathWatch是什么，它在向正在观看（现在）死去的演员的其他演员发送Terminated消息方面起着什么作用？DeathWatch又名生命周期监控。谢谢@johny，但这个评论有点神秘和模糊……你有没有碰巧写过Akka开发者文档？！？

我一直在学习java和scala中的akka，还没有完全了解代理的正确使用。我担心使用它们，因为它们包含状态，感觉它们只是程序员称之为全局状态的邪恶东西的漂亮的小包装。所以我有一些问题 代理是全局状态的包装器吗 与使用同步方法的远程对象（如果我们说的是分布式对象）相比，具有对代理的引用的参与者之间有什么区别 使用代理而不是参与者有什么好处？您可以发送一条消息，询问其中一个变量的当前值，然后返回一条消息，告知询问者响应时的值是什么 我不太清楚你所说的代理是什么意思。Akka使用actor模型（），

我正在寻找建立一个系统，能够处理一个需要很长的处理时间，比如说5分钟的请求流。我的目标是以最少的资源占用来加速请求处理，这有时可能是突发消息 我可以使用类似于服务总线的东西来排队请求，并拥有多个进程（在akka中称为Actors），可以订阅消息并开始处理。还可以有一个看门狗来查看服务总线中的队列长度，创建更多的参与者/参与者系统，或者停止一些 如果我想在Actor系统中做同样的事情，比如Akka.net。说这样的话： 我可能希望根据我的请求队列长度启动/停止新的远程参与者系统 将消息发送给任何

我正在浏览akka文档和其他维基。谁能告诉我在Akka框架中调度器和路由器之间有什么区别吗？调度器和路由器是Actor系统的两个不同概念。dispatcher基本上是一个线程池，这意味着dispatcher可以用来执行任意代码，当然，您可以自定义线程池的配置，在fork join pool和thread executor之间进行选择，设置最大/最小并行级别，检查默认dispatcher配置。虽然术语“路由器”与部署过程和指定路由逻辑有关，以将消息路由到路由对象列表，您可以在其中为池/组选择合适的

我在参与者中有一个case对象，如下所示： object UserActor{ case object getResult def props = Props(new UserActor) } class UserActor extends Actor { def receive = { case getResult => val reply = sender reply ! "Hello world" }

我们有一个actor结构，其中有一个集群分片actor，它计算一个大约7兆的参数矩阵，并且必须将其分配给其他五个节点以供使用。首先，有以下限制： 矩阵必须在一个地方生成 所有节点都需要矩阵来处理用户负载 矩阵将定期再次生成以处理变化的变量，然后发送到所有节点以处理用户负载 将矩阵保存在数据库中可能是不可行的，因为它只会转移网络负载，并且数据库会很快变得非常大。数据库仅保存输入参数 我们将Akka最大消息大小更改为10兆以实现此目的，但这感觉有点奇怪，我们没有看到其他选择。正常情况下，这很好，即使

我正在努力正确设计akka集群中两个单独的akka微服务/有界上下文之间的通信 假设集群中每个节点有2个微服务。 这两种微服务都基于akka 我很清楚，在特定的有界上下文中的通信将通过从参与者发送消息到参与者或者从节点1上的参与者发送消息到节点2上的参与者（如果必要）来处理 Q:但是在单独的akka应用程序之间使用类似的通信可以吗？e、 g.boundedContext1.actor--消息-->boundedContext2.actor 或者应该通过更清晰的边界来完成：在bc1中提出一个事件-

Akka监督策略允许自定义行为，具体取决于引发的异常类型，因此监督者可以选择是停止、重新启动、恢复失败的参与者，还是将错误升级到其父级。当一个参与者因CircuitBreakerOpenException失败并且需要重新启动时，我正在尝试构建一个自定义的主管策略。如果我只是选择重新启动策略，参与者将立即重新启动，这没有意义，因为它将在重置超时时间间隔内立即再次失败。因此，正确的行为是等待XXX秒，然后使用Restart指令。但这种行为不能用演员监督策略来表达 实施这种行为的正确方式是什么？当然，

我使用一个一致的hashingrouter将数据从一个参与者分发到一组其他参与者。每条消息都包含一个元组，如下所示（items:Set[Int]，msg:String）。我编写了一个case类，它实现了ConsistentHashable，将整数集定义为如下一致的哈希键 case class Message(items: Set[Int], msg: String) extends ConsistentHashable { def consistentHashKey = items }

我有一个由15个节点/盒组成的集群。我大致同时启动节点。其中一个节点行为异常，并不断记录忽略接收到的针对其他人的流言蜚语。但是，在从集群中删除节点之前，该节点似乎确实工作了一段时间。基本上，这一节点似乎认为它是另一个人，同时也表现为自己。所有15个节点上的代码和配置都完全相同，因此我不明白为什么只有一个节点出现此问题。也许这是硬件问题 一些日志记录： 11:27:45.412 INFO [main] Remoting - Starting remoting 11:27:45.638 INFO

我正在使用Akka.NET实现一个actor系统，其中一些actor是按需创建的，在可配置的空闲期后被删除（为此我使用Akka的“ReceiveTimeout”机制）。这些参与者中的每一个都由一个密钥标识，并且不应该存在具有相同密钥的两个参与者 这些参与者当前由一个普通主管创建和删除。可以要求主管返回与给定密钥匹配的参与者的引用，如果具有该密钥的参与者尚不存在，则可以返回现有的参与者，也可以创建新的参与者。当一个参与者收到“ReceiveTimeout”消息时，它会通知主管，主管会用“毒药丸”杀

我是Akka的新员工，我正试图了解主管策略和儿童演员终止。我有几个非常相似的担忧 首先，我的理解是，如果一个参与者创建了另一个参与者（通过context.actorOf（…）），那么它将自动成为该参与者的家长/主管。这是演员成为另一个演员的家长/主管的唯一方式 如果我上面所说的任何错误，请先纠正我！但是，假设我或多或少已经走上正轨，那么当多个父角色创建同一个子角色的实例时会发生什么情况： // Groovy pseudo-code. class Fizz extends UntypedActor

以下是我基于Stackoverflow阅读的假设 您有多个系统组件： 数据库 认证 网 每个系统组件都在单独的主机上运行，如microservice模式中所述。在其他情况下，要将这些主机粘合在一起，您需要： 运行一个作为每个主机上的种子节点之一运行的参与者系统 描述每个主机的角色，以便将消息定向到正确的组件 以下是我的问题： 您能否不在每个主机上运行Actor系统，并且仍然链接到集群 您如何根据角色直接发送消息？假设我想将数据库消息从web组件定向到数据库组件 经过一些研究，找出答案 1）

iam在我们的play scala项目中开发了反应式卡夫卡，在该项目中，我们创建了5个主题，这些主题由消费群体订阅，效果良好，现在的问题是我创建了一个新主题，如何将此主题添加到现有消费群体中（可能吗） 我的代码是： val consumerSettings = ConsumerSettings(system, new ByteArrayDeserializer, new StringDeserializer) .withBootstrapServers(bootStrapServer

自从我上一个Akka项目以来，Akka已经转向了更面向集群的方法 我喜欢akka.actor.typed提供的模式。但我不是在构建集群系统。我研究了集群，但我认为我的系统过于分散，比一个合理集群的系统更静态 我有一个系统的骨骼，但我不能形成连接，因为我不能用ActorSelections来连接我的节点。我在akka.actor.typed中搜索过，没有找到创建ActorSelection的路径 有没有办法从akka.actor.typed中我可以访问的任何内容创建ActorSelection 是

我希望使用circe实现一个akka序列化程序。假设我已经定义了需要与其编解码器一起序列化的类，因此： @JsonCodec sealed trait Command extends JsonSerializable case class Activate() extends Command case class DeActivate() extends Command object Command 以及要序列化的类： abstract class CirceSerializer(table:

我们正在做一个内部项目，除了不是Akka的专家之外，我们更喜欢玩路由器、调度器配置和管理器。鉴于我们的应用程序可以处理大量请求，我们希望测量配置更改对应用程序性能的影响。我们知道一些在Akka上进行监控的商业工具，但我们想先做一些内部工作，比如使用Codehale的度量。有没有人知道一个简单的策略，可以通过使用类似于度量的东西来测试Akka参与者？我们也不想现场直播，我们想在受控环境的压力测试后得到一些报告 谢谢 如果您准备深入研究akka源代码，您可以在actor和dispatcher实现中插

我刚刚在Devnexus 2013上听了Josh Suereth的演讲“演员系统介绍”，感到很兴奋。我熟悉企业集成模式，有Spring集成经验 Akka能提供哪些Spring集成无法处理的好处？ 它们是竞争对手吗？或者是否有我想要集成它们的用例？首先感谢您对此事的反馈 我不熟悉阿克卡，也不确定它是否熟悉。在我看来，这与我们的情况类似 从另一方面来说，如果您熟悉Akka和Spring集成，那么欢迎您的贡献。我们有一个新的项目，您可以在该项目上启动一个新项目，我们将遵循您的PoC，并继续进行稳健的集

出于调试目的，我希望有一种编程方式来获取系统中当前未终止的参与者的树 任何可以给出\的内容都可以转换为参与者层次结构当前状态的文本表示，这也就足够了 如何实现这一点？您不能直接遍历参与者层次结构。但是，您可以向每个参与者订阅，然后让一个参与者向事件总线发送路径报告消息并收集所有响应。您可以递归遍历参与者层次结构，但由于给定系统中的参与者数量通常是弹性的，因此答案可能不可靠

我是Akka的新手，我正在尝试在Google云VM实例上运行一个在localhost上工作的简单远程处理actor VM既有内部IP，也有外部IP。当我启动一个IP设置为external的actor时，它无法启动 但是当我这么做的时候 netty.tcp { hostname = "<internal IP>" port = 45000 netty.tcp{ hostname=“” 端口=45000 一切开始都很好 现在很明显，当尝试从另一台机器连接时，内部IP无法解析，

我现在正在学习阿卡语，有些东西我不懂 我已经读过context.stop（self）停止参与者并忽略队列中的其余消息。这是真的吗 我有下面的演员，他收到“停止”信息，打印“要停止”，然后“我打印了一些东西，但我没有活着”。 如何打印第二行？我以为context.stop（self）会立即阻止演员 class Alice extends Actor { def receive = { case "stop" => println("gonna stop")

我正在为一个实验项目开发akka http（akka-http-Experiative_2.11-0.4）。我以前也没做过喷雾 我想流一个mp4视频（大小可以不同）到浏览器。但是我不知道如何为HttpResponse创建HttpEntity（HttpEntity.Chunked？）。我曾经尝试过像这样肮脏的事情，这不是一种正确的方法，但这在Firefox中只适用于单个请求 def output = Source.fromFile("C:\\Users\\karthik\\Downloads\\

Akka和我开始相互了解了 发件人： 下面是一个名为DemoActor的示例演员： class DemoActor(magicNumber: Int) extends Actor { def receive = { case x: Int => sender() ! (x + magicNumber) } } 在doc的“推荐实践”一节中指出：“在每个演员的伴奏对象上提供工厂方法是一个好主意，这有助于使合适的道具的创建尽可能接近演员定义。”他们这样做： object De

我正在寻找一个解决方案，其中几个参与者应该坐在一个线程上。在这个线程中，我有OpenGL上下文，我想将资源创建代码（例如着色器编译）与资源使用代码（例如渲染循环）分开 这可能吗？我想基于GUI的应用程序也会存在同样的问题。像Swing一样，它是单螺纹的。因此，我认为应该有一个解决办法 目前，我有以下用于渲染线程的配置： renderer-dispatcher { executor = "thread-pool-executor" type = PinnedDispatcher thr

我是Akka的新手，我正在构建一个包含许多远程节点的集群系统。远程节点称为工作节点。工人创建远程路由器链 创建路由器的父级（工作者）将有一个stats watcher，它将从路由器的所有路由对象获取消息 qn是：在创建路由器作为路由器的构造函数参数时，最好传递statswatcher actorRef，或者在路由器中传递statswatcher的actor path作为构造函数参数和用户actor选择来告诉消息 ****************更新******** 根据akka邮件组的回复，将a

我有一个参与者，它从发起方接收消息，然后询问工作者，最后将结果发送给发起方 代码中更清楚地说明了这一点： public class MyActor extends UntypedActor { private final ActorRef worker; public MyActor(ActorRef worker) { this.worker = worker; } @Override public void onReceive(O

我正在尝试测试参与者是否被终止，我知道有一种方法可以使用TestProbe的expectTerminated 但是有没有一种方法可以测试相反的情况呢 谢谢：） 更新 在我的场景中，我有一个用户actor，它有一个或多个子actor，当其所有子actor断开连接（终止）时，它将自行终止 该行为运行良好，但我的问题是，我只能测试一个场景，该场景没有子对象，并且会自行终止。我找不到正确的断言来检查它是否没有终止，如果它还剩下孩子的话 下面是一个简化的测试版本： "Terminates itself

我想读取拒绝中的参数值： parameter(paramName.as[Int] ? default).recover[Tuple1[Int]]{ case Seq(MalformedQueryParamRejection(paramName, _, _)) => complete(invalidQueryParameterError(paramName, ????)) } 相反？？？我想传递我们的参数值 有什么想法吗？看看akka.http.scaladsl.serve

我正在阅读阿尔帕卡的文件。在阅读Kafka consumer API时，我遇到了createDrainingControl（），我想知道这个函数的用途是什么？我知道这是用来排出和停止流的，但是如果我们持续使用来自Kafka MQ的消息，为什么我们需要停止流？最终，您将需要部署新版本的应用程序，您必须停止当前应用程序并启动新版本的应用程序。这通常可以通过终止旧的应用程序来完成，但这会增加重播、超时或错误的数量，所有这些都取决于应用程序的操作 相反，如果您通过先排空流来优雅地停止应用程序，则会减少这

我的工作需要在应用程序终止期间进行一些高级清理，所以我在CoordinatedShutdown的服务解除绑定阶段之前添加了一个任务 当应用程序从外部接收到SIGTERM时，任务正在执行，但在应用程序内调用system.terminate时，任务未被调用 Akka doc说它应该在actor系统终止时执行，有人知道为什么它在终止时没有被调用吗

我读过这篇文件，上面写着： 参与者可以在事件流上订阅类akka.actor.DeadLetter，请参阅事件流以了解如何做到这一点 在事件流文档中：，示例代码似乎是关于经典Akka的，包是Akka.actor.ActorSystem而不是Akka.actor.typed.ActorSystem： import akka.actor.ActorRef; import akka.actor.ActorSystem; final ActorSystem system = ActorSystem.cr

使用Akka进行集群切分的所有材料都意味着从集群外部向集群中的实体发送消息。但是，同一集群的不同分片区域/分片中的实体（参与者）能否相互通信？是否有一些示例代码可用于此？（关于如何在集群中从一个实体向另一个实体发送消息）简短的回答是“是” 让我们详细说明一下： 您可以查看entityRef是已知被切分的ActorRef，因此在任何情况下，您都需要一种机制来获取该entityRef。该机制是ClusterSharding扩展。因此，使用： val sharding=ClusterSharding（

我有下面的演员设置，使用Akka演员（2.10） A-繁殖->B-繁殖->C A-发送作业->B-发送作业->C C-发送结果->A（重复） 然而，在某个时刻，A注意到它应该更改发送给B/C的工作负载，因为C正在发送大量的消息，而这些消息最终证明是无用的。然而，在这种情况下，C的收件箱似乎很满，和/或C可能被阻止 A如何告诉B立即关闭C？丢失B和C的状态和消息是可以接受的，因此销毁它们并生成新消息是一种选择。如果参与者按照您描述的方式启动，那么以正确的方式使用停止将满足您的要求。根据文件，呼叫s

我是阿克卡的新手。我建立了一个阿克卡集群。在集群中，我有一个节点作为主节点，它将工作分配给从节点。主节点将首先启动。然后从节点将向主节点注册它们的slve。如果从机优雅地离开，主机将收到一条消息 message instanceof Terminated 然后主节点将为从节点执行一些恢复。但是如果奴隶只是崩溃了，我怎么处理呢。当前，控制台将错误打印为“连接被拒绝”。谁能告诉我如何捕捉这个错误并知道这个崩溃的从节点的ActorRef，以便主节点对崩溃的从节点进行类似的恢复 非常感谢您可以维护其他

Akka.NET和原始Akka能否使用远程通信进行通信 换句话说，Akka可以用于连接系统中的JVM和CLR吗？Akka.net Github上的这个问题描述了这不起作用的几个原因： 1） 我们对用户消息使用不同的序列化程序，Akka使用 默认Java序列化程序Akka.NET使用Json.NET。这是可以解决的 通过使用例如google protobuf，序列化程序是可插入的 2） Helios（akka.net transport）和Netty（akka transport）最受欢迎 在二进

是否有可能创建一个可再现的阿克卡溪流源，以及如何实现这种行为？例如，我希望使用以下帮助器方法： def recreatable[T, Mat](source: => Source[T, Mat], delay: Duration)(implicit mat: ActorMaterializer): Source[T, Mat] = ... // using helper method recreatable(new MySource(...), 1 minute).map(...) 任何