常规Akka参与者与邮箱和dispather（线程池）关联，可以通过配置或编程方式设置。您可以通过路径查找常规演员。 常规参与者首先从邮箱中退出消息队列，然后处理消息，等等 我能对骆驼消费者演员做同样的事吗？ 普通演员和骆驼消费者演员之间有什么区别？是的，你可以对骆驼消费者演员做同样的事情。不同之处在于它将自己注册到Camel端点。谢谢您的回复。所以我的理解是，骆驼消费者将从其端点拾取消息，并将消息放入消费者的邮箱。这都是由Camel组件线程完成的。Akka线程在消息进入消费者邮箱后启动。是的，

在Akka中，当可靠代理终止时，是否可以确定哪些消息未被确认已到达目标？当可靠代理终止时，未确认消息会发生什么情况？当前2.2版本的ReliableProxy不适用。在Akka 2.3中，我有这个特性，还有一些其他的东西可以看到这个类 更新以包含Akka 2.3信息。

据我所知，演员一次只处理一条信息。我不明白为什么Apache Spark会在masterLock上同步 case SendHeartbeat => masterLock.synchronized { if (connected) { master ! Heartbeat(workerId) } } 我希望它看起来像这样： case SendHeartbeat => if (connected) { master ! Heartbeat(workerId)

我对Akka演员和演员模型有点困惑。从参与者A发送到参与者B的消息是否保持顺序？如何在本地/网络环境中实现这一点？据我所知，网络引入了可变延迟，如果M1的延迟为1秒，M2的延迟为0.5秒，那么消息M1和消息M2如何保持顺序？正如Viktor Klang posts的链接所述：基本上，您可以保证两个特定参与者之间的消息将按照发送方和接收方之间发送的顺序到达，但这并不意味着如果另一个参与者向接收方发送来自不同发送方的消息的顺序将保留在接收方队列中。Aka如果A1和A3都发送到A2，那么来自A1的所有

我正在查看akka的DistributedPubSub，希望收到Actor发来的消息，该演员最近订阅了一些活动，比如最近10分钟的活动。在API中找不到类似的内容，并且文档非常稀少。是否有任何功能到当前冥想器>代码>，就像当你加入时，你会收到所有过去的群集突变事件。你是否考虑过使用类似于“代码> RabByMQ < /COD>”之类的东西？我可能会使用Kafka，因为在akka中没有内置支持。我使用库与RabbitMQ集成。但是，是的，如果你已经熟悉卡夫卡，我想卡夫卡也会起作用，我不喜欢根据个人

我有Akka集群，在那里可以远程和本地创建演员 当创建actor时，它接收初始状态（参数，在下面的示例中） 我正在寻找一种方法来克隆初始状态，因为当本地创建两个参与者时，它们在同一引用上工作，并且具有竞争条件（当远程创建参与者时，它接收到对象的序列化副本） 在此解决方案中，即使远程发送，参数也将被克隆，因此在性能方面并不完美 我还缺少其他解决方案吗 boolean allowLocalRoutees = true; Set<String> useRoles = Set.of("wor

在akka文件中： 好消息是，Akka参与者在概念上都有自己的轻量级线程，完全与系统的其他部分隔离 什么是轻量线？线程不被认为是昂贵的资源吗？这里的关键词是“概念上”：事实上，JVM/OS线程是（相对）昂贵的资源，因此Akka不是用每个参与者一个线程来实现的——这太重了 Akka确保每个参与者一次只处理一条消息。这意味着“在参与者内部”您不必同时担心，这就是“概念上”您可以认为参与者运行在“轻量级线程”上的语句的意思（尽管在内部它不是使用每个参与者的线程来实现的）

我有很多线程和线程池的Java应用程序。我们可以用AKKA替换线程和线程池吗 这取决于线程正在执行的操作。他们是在阻止IO还是在他们之间使用锁和共享可变数据？如果是这样的话，akka可能不太合适，因为演员通常应该避免io或锁的阻塞。另一方面，如果线程执行独立的非阻塞工作，并且可以通过消息传递进行通信，那么akka可能是一个很好的选择。这取决于线程正在执行的操作。他们是在阻止IO还是在他们之间使用锁和共享可变数据？如果是这样的话，akka可能不太合适，因为演员通常应该避免io或锁的阻塞。另一方面，

我安装了typesafe activator（Windows）以使用akka框架。但当我试图启动激活器时，它并没有像Akka网站上提到的那样在浏览器中打开。我尝试使用命令提示符打开它，但它显示“jansi 1.11无法检索”错误。如何重新爱上它？看起来您无法下载正确版本的jansi.jar，不幸的是，下载中没有包含jansi.jar 如果您在Windows上使用web代理，则必须按照“代理背后”一节中描述的配置步骤进行操作。看起来您无法下载正确版本的jansi.jar，很遗憾，下载中未包含该版本

我让一个演员向另一个演员发送消息。它多次成功地执行此操作，但在几条消息之后，第二个参与者停止处理这些消息。系统本身的负载不是很高 再现问题的测试是： test("case2: Primary (in isolation) should react properly to Insert, Remove, Get") { val arbiter = TestProbe() val primary = system.actorOf(Replica.props(arbiter.ref, Per

Akka文档讨论了各种看似相互关联的Akka技术，但没有对它们进行太多区分： 阿克卡网络 阿克卡远程处理 阿克卡聚类 Akka ZeroMQ模块 我的理解是，“Akka网络”只是一个模块/库，它使Akka能够通过TCP与远程参与者系统通信。Akka远程处理是另一个模块/库（不包含在核心Akka JAR中），它使Akka能够使用八卦协议。Akka Clustering是另一个模块/库，它使用这些八卦协议允许远程参与者系统聚集在一起，并以病毒式/服务发现式的方式共享状态更改。我对Akka Zer

是否有Akka适用的特定端口范围？我以前想在2550-2570上配置它，但我不允许在生产中使用该范围。在它的位置上可以选择任何一个吗 谢谢 Akka将绑定到任何端口，只要该端口当前未在该计算机上使用。是否尝试将端口设置为零？我想零会有用的。有一个模糊的记忆在某处读到它。0只是告诉Akka选择一个随机打开的端口。对，但如何限制它使用特定的范围？

我使用Flink cluster（单机版），它在几个小时后将任务管理器与作业管理器断开连接 我遵循flink.apache.org中设置独立集群的基本步骤，使用1个主节点和2个工作节点，它们是Mac osx。 只有1名工作人员与jobManager断开连接 我共享日志文件，请给我解决方案 下面是作业经理的日志 2017-01-28 16:58:32,092 WARN org.apache.hadoop.util.NativeCodeLoader -

akka http客户端上断路器的一个示例看起来非常简单，但对我来说，它不起作用 object HttpWithCircuitBreaker extends App { implicit val system = ActorSystem() implicit val materializer = ActorMaterializer() implicit val ec = system.dispatcher val breaker = new CircuitBreaker(

我有一个方法：def-Sighting（from:YearMonth）：Future[Seq[Sighting]] 另一个：def目击（from:YearMonth，to:YearMonth）：Source[signing，NotUsed] 我想为每个YearMonth调用第一个，从from开始，到结束，然后合并/合并结果。我似乎无法在Source上找到合适的方法来实现这一点。我现在看到的是： val months = from.until(to, ChronoUnit.MONTHS) + 1

我正在使用spray can客户端编写一个http服务客户端库，它使用akka io 为了让客户端正常工作，我需要设置一些非默认的spray.can.configconfig选项（我需要设置respone chunk aggregation limit=0以正确处理大块响应） 我希望1）以某种方式将此设置捆绑到客户端，这样库的用户就不必进行任何显式配置，2）使其仅适用于我的客户端库使用spray client的情况，而不是在客户端库的用户在其他地方使用spray client的情况下不经意地错误

最近，我在我的项目中实现了一个远程参与者模式。我想知道哪条路是同时运行的演员 路1 for(int i = 0; i < 100; i++){ Patterns.ask(Props.create(Worker.class),$someJobs, timeout); } for（int i=0；i

我是Akka的新手，我们正在为多个事务构建一个健壮的系统，可以扩展到每分钟5000个请求 调度器将列表或请求推送到Akka主参与者 Akka的主要参与者有子组件的引用，在子组件上说“询问”，并等待未来，子组件与“webservice适配器”交互，适配器在其中调用Web服务 在“webservice适配器”中，我们存储对数据库的请求和响应 一旦响应可用，适配器将结果返回给Subactor，然后返回给Future，以便在Actor中进行进一步处理 问题是： 由于我们在主参与者中使用“Ask”来调用子

我正在测试Akka，在application.conf中有这个配置 akka.actor.deployment { /OperationManagerActor/StatusCheckerActor { router = smallest-mailbox-pool resizer { lower-bound = 1 upper-bound = 10 messages-per-resiz

我正在使用Spray/Akka创建一个简单的restapi，以接收json消息并将其传递给apachekafka生产者。ApacheKafka生产者是一个非阻塞API，用于向Kafka消息代理发送消息，并且是线程安全的，应该由所有线程共享 我的基本架构是路由特性中的以下伪代码 val myKafkaProducerActor = system.actorOf(Props[KafkaProducerActor]) val route = { path("message") { get

在我阅读了AKKA团队编写的这篇优秀的博客之后，我运行了代码，它确实有效 但当我做另一个实验时，稍微改变一下，在工人中抛出一个异常，那么这个模式就不起作用了。因为工人在工作中可能会抛出任何类型的异常是合理的，对吗 以下是我的代码，两个文件： Reaper.scala，摘自上述文章： import akka.actor.{Actor, ActorRef, Terminated} import scala.collection.mutable.ArrayBuffer object Reaper {

有人能帮我为下面这个抽象的Akka actor伪代码编写一个测试用例吗 我面临的问题是，所有的监控策略消息（作为测试用例的一部分发送）都被父参与者使用，而不是将其监控策略应用于子参与者 父抽象参与者创建子对象 Abstract class Parent extends UntypedActor { String name; int noOfChildActors; //this set is used to manage the children i.e noOfChildActo

我听到了很多关于阿克卡的好消息。 我有一个价格流，我需要创建两个移动平均价格。 最后，我有一个策略，它会倾听这些信号=>价格，移动平均价格1和移动平均价格2，并做出一些决定 我通过actors实现了这一点，但不幸的是，我有一个顺序问题，即a）我不知道如何为生成的消息或事件指定时间戳或优先级顺序 final ActorSystem actorSystem = ActorSystem.create("backtest"); final ActorRef strat = ActorSystem

我正在研究域驱动设计，想知道作为聚合的参与者的实例是否可以同时存在于全球网络/集群的两个地方，比如在美国和欧洲，这样在这两个地方都有工作人员的客户就不会经历任何网络延迟？从概念上讲，一个“实体”可以有两个实例在您的集群中。然而，另一个问题是如何将它们彼此同步以保持实体状态的一致性？因此，两个参与者在数据库中的同一行上使用相同的akka://address在欧洲有一名演员，美国有一名演员，而只有一排演员的情况下，“是不是不可以”，无论如何，您都会遇到延迟，因为这两个参与者必须在某个时候与该行通信。

由于不推荐使用ActorPublisher而支持GraphStage，看起来我不得不放弃actor管理的状态，而选择GraphStateLogic管理的状态。但使用actor管理的状态，我能够通过向我的actor发送任意消息来改变状态，而使用GraphStateLogic，我不知道如何做到这一点 因此，在前面，如果我想创建一个源来公开通过HTTP请求/响应提供的数据，那么使用ActorPublisher，请求通过请求消息传递给我的参与者，我可以通过在后台启动HTTP请求做出反应，并向我的参与者发

根据定义，http响应分为3部分，状态代码->标题->正文，当执行akka客户端http请求时，在前两部分完成后接收http响应 收到 val responseFuture: Future[HttpResponse] responseFuture.map { case HttpResponse(statusCode:StatusCode, headers:Seq[HttpHeader], entity:ResponseEntity, protocol:HttpProtocol)

我有akka集群和非类型的演员系统。 现在我必须将一个节点更改为使用类型化的参与者 问题是：如何从非类型化的actor系统创建类型化的shardregion？ 基本上我需要这样的smth： import akka.cluster.sharding.typed.scaladsl.ClusterSharding ClusterSharding(untypedActorSyste).sharding.spawn( behavior = entityId ⇒ counter(ent

我有一个akka应用程序，我将在许多机器上部署它。我希望这些应用程序中的每一个都通过使用分布式发布/订阅事件总线功能相互通信 但是，如果我将系统设置为集群，那么我担心一个应用程序的参与者可能会在不同的节点上创建，而不是在它们启动的节点上创建 参与者只在其所属的应用程序启动的机器上创建，这一点非常重要 基本上，我不想要参与者的弹性或集群，我只想要分布式发布/订阅。我可以看到这里提到的单件或角色等选项，但是我想知道推荐的方法是什么。目前Akka中没有可以移动参与者的功能：要么以编程方式部署到特定机器

当参与者收到Kill或ToxinKill或AddressTerminated消息时，似乎会发送AutoReceiveMessage。但在某些情况下，会发送以下类型的AutoReceiveMessage： received AutoReceiveMessage Envelope(SelectChildName(123_321,{some payload}),Actor[some actor]) 这个信息是什么意思 可以订阅这些类型的邮件吗 这些消息（包括SelectChildPattern和S

我创造了这个演员： ActorRef eventActor = system.actorOf(Props.create(EventActor.class,1),name); 现在，我想取回道具1，但我不能。你能帮我吗？在演员内部，你可以使用context.Props（Scala）或getContext（）.Props（）（Java）访问用来创建它的道具

我使用spray can、spray http 1.3.2和akka 2.3.6设置了一个http服务器。 我的application.conf没有任何akka（或spray）条目。我的演员代码： class TestActor extends HttpServiceActor with ActorLogging with PlayJsonSupport { val route = get { path("clientapi"/"orders") { complet

我正在使用Akka和Spray构建一个RESTful API。 我正在使用类型安全Akka集群示例项目 （） 作为参考。我有一个集群，它使用路由池和集群感知路由。API的接口通过一个spray前端创建一个参与者（ClusterClient），该参与者充当集群的前端，并监视集群活动（新节点、宕机节点等）。 当请求进入喷洒路由时，我通过集群感知路由器将工作委托给集群后端工作者 我的希望/目标是，通过根据需要添加更多的后端工作节点和路由，可以提高系统的性能。我还可以添加更多通过负载平衡器访问的前端（s

我现在喜欢在akka中使用redis，因为我可以通过查询redis来监控处理了哪些消息。Redis还可以持久保存到磁盘 akka持久性与仅使用redis相比如何？我想说，两种选择都不比另一种好，尽管它们提供了不同的功能。Akka持久性是关于持久化参与者处理的每个事件，以便可以重播这些事件来重建参与者的状态。它是事件源的一个实现。您还可以出于其他目的查询存储的事件，例如分析系统的行为。由于记录了每个历史事件，因此可以详细分析 另一种持久性机制可能只包含系统的当前状态，因此不可能对历史进行分析 引用

似乎Akka中的参与者越来越倾向于提供功能（远程）了 它们在多大程度上重叠或互补（国家、行为、监督、儿童等）？Ignite的文档在此主题上有点简洁，可能是我在比较苹果和梨，但我也想知道……Ignite中的分布式闭包只是：可以在远程Ignite节点上执行的闭包，而无需任何显式部署（单播、广播等）。它们没有强加传统的Actor（a-la-Akka）语义。在Ignite中，这是故意的 这是Scala中使用Ignite闭包的一个很好的例子：还有两个问题：1）您能否在回答中详细说明如何在不部署explic

我目前正在做一个广泛使用Akka和Akka流的项目 在使用它的过程中，一个问题不断出现：在所有使用流的地方，物化器的最佳实践是什么。特别是当我在Actor中时，我只能访问ActorSystem，我应该手动传递现有的Materializer实例还是在需要时创建一个 我特别担心在按需实例化Materializer时的资源使用和性能。创建Actormatarializers相当便宜，在大多数情况下，合理地增加它们不应该是一个问题 如果您追踪从actormatarializer.apply（请参阅）开始

如何获取远程创建的参与者 附言： 我正在研究akka样品/akka样品遥控器 下面是这样的情况：我有两个主机：host1，host2 部署在host2上的应用程序将通过以下配置在host1上远程创建参与者： application.conf remote_app { include "common" akka { actor { deployment { /advanced_calculator { remote = "ak

我正在尝试创建一个可以远程和本地访问的参与者。 下面创建的参与者抛出一个异常。有什么想法吗 val myLocalActor2=system.actorOf（Props[ActorNodes]，name= "akka://JtsSystem@127.0.0.1:2552/MyOwnRef“ 这是以编程方式创建本地和远程的actor的最佳且唯一的方法吗？actorOf中的“名称”只是一个路径段。这将标识新创建的参与者。请参阅此处以了解有关此方面的更多信息： 另外，拥有本地和远程的东西是没有意义

从文档中我了解到，向参与者发送Kill消息将重新启动它，但实际上它只是停止 （文档是否过期？Kill是“所有参与者都会理解的一条消息，经过处理后，参与者将抛出ActorKilledException，这将触发监视。”。因此，如果被杀死的参与者的父参与者的监控策略是Stop，那么它将不会重新启动。在akka 2.1.0中，您可以配置监护人的监督策略（即：“/user/”），该策略监督顶级用户创建的参与者。创建一个新的顶级参与者，然后在其启动前方法中创建旧的顶级参与者。这将是主管，可以通过将此代码放

我已成功创建发布服务器，但无法使用以下命令创建订阅服务器： public static void main(String [] args) { ActorSystem system = ActorSystem.create("System"); ActorRef subscriber = system.actorOf(new Props(Sub.class), "subscriber"); subscriber.tell

我使用Akka 2.2 contrib的项目ClusterSingletonManager来保证集群中始终存在并且只有一种特定类型的参与者（主参与者）。然而，我观察到一种奇怪的行为（顺便说一句，这可能是意料之中的，但不明白为什么）。每当主机退出集群并稍后加入时，都会发生以下操作序列： [INFO] [04/30/2013 17:47:35.805] [ClusterSystem-akka.actor.default-dispatcher-9] [akka://ClusterSystem/syst

请注意，以下说明仅用于说明。问题是关于akka中事件流处理的模式，而不是关于如何使用替代设计解决示例的问题 想象一个用Akka编写的复杂事件处理引擎，其中事件规则由参与者建模。消息的事件流类似于订单、订单中的项目履行、订单付款。业务规则参与者正在做一些类似于向客户开具发票和跟踪付款直至完成的事情。业务规则感兴趣的数据本质上是非常动态的，不可能知道哪些规则正在跟踪消息流的哪些部分 很天真，我们可以使用boardcast路由器风格的方法。所有业务规则参与者都会看到所有数据，如果他们跟踪的不是数据，他

我正在使用akka 2.3.0循环池 部署 /事件处理器外部 路由器=循环池 实例数=65 主题的查找使用 ActorRef transformerRouter = getContext().actorFor("akka://appName/user/EventProcessorRouter"); transformerRouter.tell(munibondAnalyticsEvent, transformerRouter); 我有一个消费者参与者接收来自主题的消息，并通过循环路由器推送

我使用Java在Akka框架中实现了一个应用程序。我有一个main-actor，它使用'Ask'方法调用sub-actor，并在60秒后超时，worker在收到main-actor的消息后调用另一个java类方法 现在的问题是，虽然我的主参与者在60秒后超时，但工作人员仍然能够与java类方法对话，而该方法正在执行不需要的操作，因为主参与者无法接收响应，尽管子参与者由于超时而返回响应 如果我的主要参与者超时，我是否可以杀死工人或阻止其进一步处理？ 我检查了一些方法，如receivetimeout

我想在现有exchange中创建一个队列以进行读取 另一个应用程序正在将消息发布到此exchange，并将它们分散到所有成员队列。我希望我的新应用程序成为这些消息的附加订户 以下操作将创建一个队列： implicit val system = ActorSystem("my-system") implicit val materializer = ActorMaterializer() implicit val executionCtx: ExecutionContext = system.di

我尝试了：EventStream->Source->Akka HTTP（SSE） 在我看来，这是行不通的，因为源代码将由Akka HTTPcomplete（source，…） 要将消息从EventStream发送到具体化的源，我需要ActorRef（有办法获得ActorRef吗？） 我在GitHub上找到了一个使用ActorPublisher的解决方案： 但是由于ActorPublisher是一个内部API，我仍然希望有一个干净的解决方案。您可以使用它创建一个源代码，将事件流元素转换为实例，

我正在使用Akka Streams和Akka Http编写一个应用程序，它需要连接到经过身份验证的web服务（返回身份验证令牌），然后需要定期查询该服务，并可能使用该服务执行其他操作以响应查询（下载文件等）。身份验证令牌在一定时间后超时，因此需要刷新 我应该如何处理身份验证令牌？它需要传递到图中的不同流（无论我在哪里查询服务），当身份验证令牌变得无效时，我需要请求一个新的令牌 一种想法是在流之外执行身份验证请求，然后在流具体化时传入令牌，以便每个流在具体化过程中获得令牌作为参数。然后，当令牌最终

我们在不同的AWS数据中心中有三个节点，其中一个是唯一的种子节点和单例的独占拥有者，通过在单例代理设置上使用.withDataCenter完成。通过先启动种子节点，然后启动其他节点，我们可以让集群按照设计的方式工作，但如果任何节点发生故障，让它们再次对话的唯一方法似乎是以相同的方式重新启动整个集群。我们希望让它们尝试重新连接到种子节点，并在可能的情况下恢复正常操作 当我取下非种子节点时，种子节点将其标记为不可访问，并开始定期记录以下内容： 与远程系统的关联[akka。tcp://applicat

我已经学了几天Akka，我有一个简单的问题来理解它。应该如何为使用参与者的REST服务创建应用程序体系结构？参与者应： 一个简单的组件（例如服务层、DAO、控制器等） 参与者应该是商业逻辑元素。例如，我有一个业务逻辑，它应该被引导到作为参与者的任务中 演员=微服务。这是一个高层。应用程序中的每个微服务都应该作为单独的参与者工作 我不能这样理解它——我应该如何正确使用演员？如果我创建一个带有层（控制器、服务、DAO和数据库）的REST服务，我应该如何将其作为Akka应用程序中的参与者进行分离？

我有以下配置 akka{ actor { deployment{ /my-router { dispatcher = akka.actor.my-dispatcher router = round-robin-pool nr-of-instances = 100 cluster { enabled = on max-nr-of

我在app.config文件中有我的主hocon配置，并尝试使用fallback配置从代码隐藏中设置连接字符串。但当演员系统启动时，它就不工作了。这是我的hocon配置和C代码，如下所示。有人能帮我吗 Hocon配置我有注释输出连接字符串，用于从回退配置获取它 阿卡坚持{ journal { plugin = "akka.persistence.journal.sql-server" sql-server {