Akka ActorRefSource消息顺序
Akka是一种基于Actor模型的并发编程框架，它提供了一种轻量级、高性能的消息传递机制。在Akka中，Actor是并发计算的基本单元，而ActorRef则是对Actor的引用。
ActorRef是Akka中用于发送消息给Actor的对象。它是一个轻量级的、线程安全的引用，可以用来向特定的Actor发送消息。ActorRef隐藏了Actor的具体实现细节，使得消息发送者无需关心消息是如何被处理的。
消息顺序是指消息在发送和接收过程中的顺序。在Akka中，消息是异步发送和接收的，因此消息的顺序不是严格保证的。这意味着，如果发送多个消息给同一个ActorRef，这些消息可能会以不同的顺序被接收和处理。这种非确定性的消息顺序是Actor模型的特性之一，它允许并发执行和消息处理的灵活性。
尽管消息顺序不是严格保证的，但Akka提供了一些机制来处理消息的顺序性要求。例如，可以使用消息队列来保证消息的顺序性，或者使用有序消息处理器来确保消息按照特定的顺序被处理。
在Akka中，ActorRef的使用非常广泛，它可以用于构建各种并发应用和分布式系统。由于Akka的高性能和可伸缩性，它在处理大规模并发和分布式计算方面具有很大优势。
推荐的腾讯云相关产品是腾讯云容器服务（Tencent Kubernetes Engine，TKE）。TKE是腾讯云提供的一种基于Kubernetes的容器管理服务，它可以帮助用户快速构建、部署和管理容器化应用。TKE提供了高可用、高性能的集群管理能力，可以轻松扩展和管理大规模的容器集群。用户可以使用TKE来部署和管理Akka应用，实现高并发和分布式计算。
更多关于腾讯云容器服务的信息，请参考：腾讯云容器服务
相关·内容
我有以下akka http拒绝处理代码取自https://doc.akka.io/docs/akka-http/current/routing-dsl/rejections.html val message = "The requested resource could not be found."
implicit def myRejectionHandler = RejectionHandler.newBuilder()
.handleNotFound {
complete(HttpResponse(NotFound
,entit
浏览 25提问于2020-03-26得票数 0
回答已采纳
1回答
我正试着对akka更加熟悉。目前，我正在以非常简单的方式发送消息(下一步是发送ActorRef)。但是当我试图发送带有消息的数据时，我的目标参与者无法识别它。
下面是我写的代码：
import akka.actor.Actor
import akka.actor.Props
import akka.pattern.gracefulStop
import scala.concurrent.duration._
import akka.util._
import scala.concurrent._
import java.util.concurrent._
import scala.Array.
浏览 2提问于2014-08-12得票数 0
回答已采纳
1回答
从iOS发送C++协议缓冲区消息
、、、、
在中，人们在构建我的Akka套接字服务器时，向我展示了我的方法的错误，并且我现在实际上有了一个Akka套接字客户端，它可以发送以下帧的消息：
消息长度:4字节消息类型:4字节消息负载：(长度)字节
下面是我用来发送消息的iOS代码：
NSInputStream *inputStream;
NSOutputStream *outputStream;
CFReadStreamRef readStream;
CFWriteStreamRef writeStream;
CFStreamCreatePairWithSocketToHost(NULL, (CFStrin
浏览 1提问于2013-02-04得票数 1
1回答
我读到过：
Akka确保一个参与者的每个实例在它自己的轻量级线程中运行，并且它的消息一次只处理一个。
如果AKKA参与者按顺序处理其消息，那么AKKA如何为单个Actor提供并发性。
浏览 2提问于2016-01-15得票数 2
1回答
如果我在中使用。我为藏物设置了一个配置：
akka{
actor {
queued-dispatcher {
mailbox-type ="akka.dispatch.UnboundedDequeueBasedMailBox"
}
}
}
我想去藏起来的消息应该存储在UnboundedDequeueBasedMailBox中。我的见解是错误的吗?如果是的话，UnboundedDequeueBasedMailBox的真正目的是什么？
我能收到去stash的消
浏览 3提问于2016-10-25得票数 2
回答已采纳
试着用
val nullablestr = hornetQMessage.getBodyBuffer.readNullableSimpleString.toString
或
val strMessage = hornetQMessage.getBodyBuffer.readString
获取
org.hornetq.core.buffers.impl.ChannelBufferWrapper.readSimpleStringInternal(ChannelBufferWrapper.java:83) at org.hornetq.core.buffers.impl.ChannelBuffer
浏览 1提问于2013-06-09得票数 0
1回答
我对Akka Actors和Actor Model有一点困惑。从执行元A发送到执行元B的消息是否保持顺序？如何在本地/网络环境中实现此目标？据我所知，网络引入了可变时延，如果M1的时延为1秒，M2的时延为0.5秒，消息M1和消息M2如何保持顺序？
浏览 8提问于2015-12-01得票数 0
假设我有一系列消息，其中包含标识客户端的id。不同客户端的消息可以并行处理。同一客户端的消息一次只能处理一条。
使用Akka，我希望能够将消息路由到参与者池，但满足每个客户端id最多一个并发参与者的限制。
实现这一目标的最佳方式是什么？我是否误解了Akka背后的任何概念，或者试图应用不适合角色模型的传统概念？
浏览 4提问于2017-02-01得票数 0
我使用akka.net持久性在sql server数据库中存储了一些消息类型。在该业务场景中，它是有效的。在其他情况下，我只想使用C# .net反序列化消息，并查看没有akka.net的消息属性。这怎么可能呢？
浏览 6提问于2017-04-25得票数 0
2回答
我试图理解何时使用，并发现比主要的Akka文档更有帮助。所以看起来阿克卡期货公司做的事情和完全一样。所以我问：
在参与者系统之外，Akka期货对Java期货有什么好处？什么时候使用每一个？
在演员系统的背景下，为什么要使用Akka未来？不是所有参与者之间的消息都是异步的、并发的和非阻塞的吗？
浏览 5提问于2015-06-04得票数 16
回答已采纳
1回答
我正在开发一个使用Akka Kafka连接器的Kafka消费者应用程序。我希望消费者并行处理消息。我应该选择哪个消费群体？？如何在消费者端配置并行度？
浏览 16提问于2020-05-06得票数 0
1回答
等待多个Akka FSM消息
、、、、
我有一个Akka演员，它在ReadyState中收到消息后运行以下伪代码
lookupA ! Wrapper(Lookup("A"))
lookupB ! Wrapper(Lookup("B"))
lookupC ! Wrapper(Lookup("C"))
goto(LookingUpDataState) using DataFound(a = None, b = None, c = None)
然后，参与者等待可以是FullResult[T] (扩展ServiceResult[T])或Empty (扩展ServiceResult[Nothin
浏览 5提问于2014-07-21得票数 3
回答已采纳
我正在学习和理解阿克卡演员模型与一些基本的例子。
我为同一个Actor (即"helloworld1“和"helloworld2”)创建了两个实例，并向该Actor发送消息。第一条消息由实例"helloworld1“发送，第二条消息由"helloworld2”发送。
当我运行下面的代码时，输出如下所示
Yes you made it Hi helloworld2
Yes you made it Hi helloworld1
我的问题是，为什么第二条消息是第一次处理？我期望输出如下所示，因为第一条消息是由helloworld1发送的
Yes you made it
浏览 2提问于2016-10-08得票数 1
回答已采纳
我最近了解了akka，但有些想法我不能理解。我的问题是，如果队列中的消息太多，是否会创建一个新的参与者？
在许多框架中，例如，一个http-requet消息到来，并且该框架发现当前“工作者”正忙，因此该框架将创建另一个“工作者”来处理另一个线程中的新消息。
但是似乎akka不是这样做的，只有一个actor实例。
所以我认为“忙碌的演员”将阻塞队列，这将影响整个过程和性能，我说的对吗？
浏览 0提问于2016-01-30得票数 0
我尝试移植从Scala角色向Akka角色发送"Ping“和"Pong”的，但我一直收到错误，我想知道这只是一个简单的错误还是一些根本的错误。
考虑下面的代码：
import akka.actor.Actor._
import akka.actor.Actor
case class Message(text: String)
class PingPongActor(name: String) extends Actor {
def receive = {
case Message(msg) =>
println("receive
浏览 1提问于2011-10-08得票数 4
回答已采纳
1回答
在我们的项目中，我们将消息发布到JMS代理或从JMS代理消费消息。我们有一个PL/SOL生产者和一个Java消费者。但问题是，生产者的速度是消费者的10倍。因此，在读取和处理消息时，我们希望将使用者更改为使用多线程。
但是我们也需要保持消息的顺序。也就是说，消息应该按照它们发布到jms代理的顺序发送到目标系统。我是Akka的新手，我正在尝试了解它的特性。我们可以使用akka调度程序来实现这一点吗？
浏览 0提问于2015-10-26得票数 0
我有下面的示例参与者代码。
object SomeExternalDep {
private var flag = true
// this function will throw an exception once when called with the value 3, then it won't throw another exception
@throws[RuntimeException]
def potentiallyThrows(curr: Int): Unit = {
if (curr == 3 && flag) {
浏览 0提问于2019-07-10得票数 1
回答已采纳
我一直在玩Akka的持久性，并编写了下面的程序来测试我的理解。问题是，每次运行这个程序时，我都会得到不同的结果。正确的答案是49995000，但我并不总是明白。我已经清除了每次运行之间的日志目录，但没有任何区别。有人能看到出什么问题了吗？程序简单地将所有数字从1加到n(在下面的代码中，n是9999 )。
正确的答案是：(n * (n+1)) / 2.对于n=9999，是49995000。
编辑:与JDK 7相比，JDK 8似乎更一致。我应该只使用JDK 8吗？
package io.github.ourkid.akka.aggregator.guaranteed
import akka.ac
浏览 2提问于2014-12-21得票数 7
回答已采纳
正如akka博士所描述的，akka会发送信息-忘了-。
但是在ask模式中，如果typekey不存在，我仍然需要等待响应使用超时。
在向不存在的typekey发送消息时，是否有一种立即失败的方法？
浏览 7提问于2022-11-25得票数 1
回答已采纳
1回答
我有一个问题，它要求我的参与者按照消息发送的顺序处理消息。在Akka中，参与者A和参与者B之间的消息总是保证按照发送的顺序到达。这似乎不是服务结构中的可靠参与者的情况。在我的测试用例中，消息是以不确定的顺序接收的。
我可以通过在处理第一条消息之前不发送下一条消息来强制排序，但这违背了整个要点。我真的很想发送和忘记消息，但知道它们将由接收参与者按顺序处理。
有没有人看到这样做的模式？我认为Orleans Actors也有同样的失序信息可能性。也许Orleans的解决方案也可以在这里工作。
浏览 2提问于2015-12-08得票数 0
1回答
我有一个演员，它接收消息，并通过httpclient下载文件。
代码示例：
@Override
public void onReceive(Object message) throws Exception {
HttpClient client = new DefaultHttpClient();
...
httpGet.releaseConnection()
...
}
几天后问题就出现了。
从日志中，它显示了httpclient请求中的执行元块。
块是可以的，但是看起来httpclient死锁了，actor不会进一步处理任何消息。
这是怎么发生的？
日志：
浏览 2提问于2014-12-09得票数 1
我读过一位阿克卡演员一个接一个地处理信息。为什么会这样呢？
我无法理解的是“为什么消息的同步执行是默认行为？”我确实理解，对于邮箱消息的并行执行，函数(要执行的作业)应该有0的副作用。
这是默认的akka行为，因为具有绝对独立执行和0副作用的用例是少数，我们通常处理需要公共资源的作业。
如果scala和的设计目标是0副作用代码，下面的场景是正确的，那么为什么在akka参与者消息处理中这不是默认行为。
浏览 3提问于2016-12-15得票数 2
回答已采纳
3回答
从课件上的反应性编程的类原理来看：
“如果一个参与者向同一个目的地发送多条消息，它们就不会出现故障(这是Akka特有的)。”
行动者A和B
A发送B msg1 A发送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
浏览 0提问于2014-12-11得票数 2
回答已采纳
我有一个使用Play Framework2.2.0构建的示例-scala，它使用WebSockets将数据流式传输到客户端。我遇到的问题是，无论出于什么原因，父Actor的一个子Actor都没有正常关闭。所有日志都表明它正在停止并已关闭，但我看到它并没有通过向其发布数据而真正关闭。下面是一些代码，首先是我的控制器操作：
def scores(teamIds: String) = WebSocket.async[JsValue] { request =>
val teamIdsArr:Array[String] = teamIds.split(",").distin
浏览 5提问于2013-10-20得票数 5
1回答
基于这个问题，，我实现了一个简单的akka层次结构，以便在两个参与者之间共享数据：
package playground
import akka.actor.{Actor, ActorRef, ActorSystem, Props}
case object GetFromDb
case object GetList
case object ProcessList
class ParentActor extends Actor {
var fromDb: List[Int] = List()
def receive = {
case GetFromDb =>
浏览 4提问于2019-09-25得票数 0
回答已采纳
我有一个演员p: ParentActor，当它通过使用postStop方法停止时，我想做一些清理工作。其中一项工作涉及向儿童演员c: ChildActor发送消息。在此之后，应该停止c和p。但是，一旦context.stop(p)被调用，c似乎立即停止，无法接收消息。
下面是我想要做的事情的一个例子：
class ParentActor extends Actor {
...
override def postStop {
logger.info("Shutdown message received. Sending message to child...")
浏览 5提问于2017-08-08得票数 1
回答已采纳
3回答
暂停Akka演员
、、
我试图使用Akka来实现以下功能(我认为我正在尝试以正确的方式使用Akka )：
我有一个系统，其中有n个资源侦听器。实质上，资源侦听器是一个实体，它将侦听输入资源并发布它看到的内容(例如轮询数据库、跟踪日志文件等)。
所以我想用Akka演员来做这些小的工作单元(监听资源)。我注意到Akka给了我一个线程池，它可能少于侦听器的数量。不幸的是，从这些资源侦听器获取消息可能会阻塞，所以在下一条消息弹出之前，可能需要几秒钟、几分钟的时间。
是否有任何方法来挂起资源侦听器，以便它将线程留给另一个参与者，我们稍后会回到它？
浏览 6提问于2012-10-24得票数 1
回答已采纳
我正在尝试使用sbt将Scala/Play应用程序部署到Heroku，但是我一直收到以下错误：
remote: Downloaded https://repo1.maven.org/maven2/org/typelevel/machinist_sjs0.6_2.12/0.6.2/machinist_sjs0.6_2.12-0.6.2.jar
remote: [info] Compiling 626 Scala sources to /tmp/scala_buildpack_build_dir/shared/.js/target/scala-2.12/classes...
remo
浏览 7提问于2022-08-11得票数 0
回答已采纳
2回答
Akka:等待多条消息
、、、
嗨，阿克卡古鲁：)你能在这门课上引导我吗？
我想做的是--演员A要求演员B给我一个信息，然后等待一个人回来。但是，演员B给A的不是一条信息，而是其中的四条。Actor A Future正确完成，但3条rest消息被计算为死信。为什么？是这样的吗？我的意思是，演员A有一个适当的处理程序，为什么信死了呢？
INFO ForkJoinPool-2-worker-7得到的结果是pong信息参与者-akka.actor.default-dispatcher-4消息java.lang.String从Actorakka://Actorakka/user/b#-759739990到Actorakka://A
浏览 6提问于2013-11-22得票数 1
回答已采纳
1回答
假设我想在akka中实现ProgrammableRemote -
ProgrammableRemote
- WatchMovie
1. Tv ! PowerOn
1.1 Tv ! ChangeInput 3
2. DVD ! PowerOn
3. AVReceiver ! PowerOn
3.1 AVReceiver ! SetInput 'DVD'
我可以使用futures来排序1和1.1 (以及3.和3.1)。但是，这将导致1.1在与参与者的接收线程不同的线程
浏览 0提问于2012-10-21得票数 4
我使用slick在数据库中存储数据，在那里我使用threadLocalSession来存储会话。
存储库用于执行crud，我有一个Akka服务层来访问精巧的存储库。
我找到了这个链接，Adam Gent在这里问了一些和我在这里问的类似的问题：
我关心的是akka如何处理消息，因为我将数据库会话存储在threadLocal中，我可以在同一线程中同时处理两个消息吗？
假设:两个add user消息(A和B)发送到用户服务，消息A被部分处理，然后停止，线程B开始在线程A已开始处理的同一线程中处理，该线程将会话存储在它的localSession中？
浏览 1提问于2013-01-17得票数 3
回答已采纳
当接收事件时，Akka Actors将一次处理一条消息，在进入下一条消息之前阻塞，直到请求完成。
这对于同步/阻塞任务很有效，但是如果我想执行异步/非阻塞请求，Akka将继续处理，而不等待任务完成。
例如：
def doThing():Future[Unit] = /* Non blocking request here */
def receive = {
case DoThing => doThing() pipeTo sender
}
这将调用doThing()并开始处理将来的消息，但不会在处理下一条消息之前等待它完成-它将尽可能快地简单地执行队列中的下一条消息
浏览 1提问于2016-04-13得票数 19
1回答
我对akka、akka remoting和akka集群还很陌生。我已经使用以下配置构建了一个系统
Application.conf
akka {
actor.provider = "akka.cluster.ClusterActorRefProvider"
extensions = ["akka.contrib.pattern.ClusterReceptionistExtension"]
actor.provider = "akka.cluster.ClusterActorRefProvider"
remote{
浏览 3提问于2015-03-26得票数 0
1回答
如何处理要以特定顺序执行和完成的参与者之间的消息？
换句话说，如果Message A希望总是在Message B之前被接收，那么如何使用akka呢？
浏览 2提问于2013-12-19得票数 1
回答已采纳
正如在中解释的那样，akka提供了优先邮箱，如果您想要在处理某种类型的消息之前处理其他类型的消息，它会有所帮助。我没有在storm文档中找到类似的功能，apache-storm中有类似的支持吗?或者如何实现类似的行为？
浏览 3提问于2017-10-27得票数 0
1回答
(免责声明:我还不是akka的初学者)
假设我有一个参与者调用一个永不终止的方法(这是一个极端的例子，您可以考虑调用一个有机会在很长时间内终止的方法，或者永远不会终止)。
例如(Java)
public static class InfiniteLoop{
public static int neverReturns(){
int x = 0;
while(true){
int++;
}
return x;
}
}
现在，如果在处理消息时，参与者调用
InfiniteLoop.neverReturn
浏览 1提问于2017-11-07得票数 0
回答已采纳
2回答
我在Akka 1.3中对消息使用zlib压缩。我现在正在迁移到Akka 2.0 RC2，似乎在Akka文档(用于Akka 2.0 RC2)中不再提到消息压缩。
这是否意味着在Akka 2中不再支持消息压缩，或者压缩正在幕后进行，但压缩选项不再可配置？
谢谢。
浏览 0提问于2012-02-24得票数 4
回答已采纳
我试图在F#中使用远程发送一条消息，但是我一直遇到这样的问题:没有发送带有类型的消息。当我使用以下代码时：
Server.fsx
#r "nuget: Akka.FSharp"
#r "nuget: Akka.TestKit"
#r "nuget: Akka.Remote"
open System
open Akka.FSharp
open Akka.Remote
open Akka.Configuration
let configuration =
ConfigurationFactory.ParseString(
浏览 2提问于2020-12-01得票数 3
回答已采纳
我为编写了一个自定义记录器，将日志消息传递给远程系统。我有第二个记录器，它使用和作为后端打印到控制台和日志文件。
奇怪的是，我注意到一些消息没有被我的自定义记录器接收，但是slf4j记录器接收得很好。
例如，作为监督策略的一部分，由失败的子参与者生成的错误消息被记录：
[DEBUG][akka://Test/system/remote-deployment-watcher]: started (akka.remote.RemoteDeploymentWatcher@b342d63)
[DEBUG][akka://Test/system]: now supervising Actor[akka:
浏览 0提问于2014-09-03得票数 3
回答已采纳
1回答
我在Java内部使用Akka参与者，并试图打开消息的日志记录。基于，设置akka.actor.debug.receive似乎会导致记录所有消息。下面的测试应该记录正在发送和接收的"hello"消息。
import akka.actor.AbstractLoggingActor;
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.japi.pf.ReceiveBuilder;
import akka.pattern.Patterns;
im
浏览 0提问于2015-09-17得票数 4
回答已采纳
1回答
阅读akka的文档，我不太清楚消息的顺序，以及是否可以强制执行。让我用我为聊天服务器编写的一小部分代码来设置我问题的上下文。
def flowShape(user: User) = GraphDSL
.create(Source.actorRef[ChatMessage](bufferSize = 5, OverflowStrategy.fail)) {
implicit builder =>
implicit chatSource =>
import GraphDSL.Implicits._
val messageFromOut
浏览 4提问于2017-11-11得票数 0
回答已采纳
当一个演员被杀的时候，我正试图传达一个信息。
这是基于Akka死亡观察文档：
在serviceActor中，我在等待一条“杀死”消息，但我从未真正发送过这条消息。因此，要在ServiceActor中接收消息，我使用：
else if (msg instanceof Terminated) {
final Terminated t = (Terminated) msg;
if (t.getActor() == child) {
lastSender.tell(Msg.TERMINATED, getSelf());
}
浏览 2提问于2014-10-08得票数 0
回答已采纳
1回答
上个星期，我深入研究了阿克卡博士，最终了解了什么是参与者系统，以及它们解决了哪些问题。
我对传统JMS/AMQP消息代理的理解(和经验)是，它们存在是为了提供以下内容：
生产者和消费者之间的异步处理；以及
消息传递保证，包括持久性、重试和回退
但是，Akka不是在没有所需的基础设施和运营开销的情况下提供这种服务吗？
在Akka中，所有的Actor通信都是异步和非阻塞的；
在Akka中，SupervisorStrategies的存在是为了完成重试、后退和升级。如果需要的话，可以将参与者配置为持久化到几乎任何类型的存储。
因此，我想知道:如果我的应用程序使用Akka，我是否需要将JMS/AMQP代
浏览 0提问于2015-07-24得票数 23
1回答
情况
我正在使用akka演员更新我的网络客户端的数据。这些参与者中的一个完全可以发送有关单个Agent的更新。这些代理更新非常快(每10 is更新一次)。我现在的目标是控制这种更新机制，以便每一个Agent的最新版本每300 My发送一次。
我的代码
到目前为止，这就是我想出来的：
/**
* Single agents are updated very rapidly. To limit the burden on the web-frontend, we throttle the messages here.
*/
class BroadcastSingleAgentActor e
浏览 0提问于2019-03-26得票数 2
回答已采纳
我正在尝试实现一个Akka角色，它接收一条消息，然后等待接收另一条消息而不循环。我尝试以这种方式实现它的原因是因为我需要在第二个case语句中的第一个case语句中接收到的对象。下面是我的意思的一个例子。 def receive: Receive = {
case s @ start =>
receive {
case e @ end =>
println(f"Received ${s} and ${e}")
}
} 我知道这可能不是理想的模式。然而，我仍然是Akka和Scala的新手，不知道
浏览 14提问于2019-12-17得票数 0
回答已采纳
1回答
我有一个运行在Android设备上的Akka系统，它通过Akka远程处理与服务器上的Akka系统对话。
Android设备可以获得任何IP地址，在应用程序运行时IP可能会更改，并且IP可能无法从服务器访问。因此，我用akka.remote.netty.hostname = "0.0.0.0"和akka.remote.netty.port = 8000在安卓设备上配置了Akka。
Android系统获取对服务器上某个参与者的引用，向其发送消息，服务器上的actor记录发送方() actorRef并继续向其发送消息。当服务器和Android设备都在同一个wlan上时，以及当他们通过
浏览 2提问于2013-04-18得票数 2
回答已采纳
1回答
我正在寻找一种在akka.net中锁定消息队列的方法。
我有一个专用的Actor，它使用外部组件(有状态)执行请求数据/读取响应，它只做这件事(没有逻辑)
我有一个角色A，它向专职的角色发送消息。根据响应的内容，可以要求发送特定的消息。
还有一个Actor B，他向专用actor发送消息，但使用其他逻辑、其他功能，但同样适用于此处，根据响应，发送特定的新请求。
但发送给专用Actor的消息不能混合。因此Actor A可以使用专用Actor，当完成时，Actor B可以开始向专用Actor发送消息。
是否有一种机制来锁定专用执行元的消息队列？
提前谢谢你，
林蒂
浏览 6提问于2021-06-12得票数 0
因为spark是建立在Akka之上的，所以我想使用Akka在spark集群之间发送和接收消息。
根据本教程，我可以在本地运行StreamingApp并向actorStream本身发送消息。
然后，我尝试将发送者部分附加到我的另一个spark master上，并将消息从spark master发送到StreamingApp中的远程actor。代码如下
object SenderApp extends Serializable {
def main(args: Array[String]) {
val driverPort = 12345
val dri
浏览 0提问于2015-03-06得票数 1
我在SBT下有多模块项目。
Project A (库)有带有A配置参数的reference.conf文件，项目A依赖于带有自己的reference.conf文件的akka-actor库，Project A在自己的reference.conf中重新定义了akka的一些参数。
项目B依赖于A。
当我在ConfigFactory.load()中调用B时，reference.conf的合并顺序是错误的。它首先接受A的配置，然后应用akka-actor的配置，最后，我得到了akka-actor的初始配置。
我怎么才能修好它？我需要先加载akka-actor的配置，然后应用A的配置。
浏览 3提问于2015-07-29得票数 9
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
云直播
对象存储活动推荐
腾讯云开发者
