Akka:在ask上丢失了对`child.path.name`的引用
Akka是一个开源的分布式计算框架，用于构建高可伸缩、高并发、可容错的分布式应用程序。它基于Actor模型，通过消息传递实现并发和分布式计算。
在Akka中，ask是一种用于向Actor发送消息并等待其返回结果的机制。然而，在使用ask时，可能会遇到对child.path.name引用丢失的问题。
child.path.name是指Actor的路径名称，用于唯一标识一个Actor。当使用ask向一个Actor发送消息时，如果在等待结果的过程中，该Actor被重新创建或者被销毁，那么对child.path.name的引用就会丢失。
为了解决这个问题，可以使用Actor的引用（ActorRef）来代替对child.path.name的引用。Actor的引用是一个不可变的对象，它可以在Actor重新创建或销毁后仍然有效。通过使用Actor的引用，可以确保在使用ask时不会丢失对Actor的引用。
对于Akka的应用场景，它适用于构建高并发、分布式、可容错的系统，特别是在需要处理大量并发请求或者需要实现消息驱动的系统中。例如，社交网络应用、实时数据处理系统、游戏服务器等都可以使用Akka来实现。
腾讯云提供了一系列与Akka相关的产品和服务，包括云服务器、容器服务、消息队列、数据库等。具体推荐的产品和产品介绍链接地址可以参考腾讯云官方网站的相关页面。
相关·内容
1回答
我目前正在学习与Akka和Scala玩游戏。
Akka文档说，您可以通过使用?或ask方法从参与者那里获得一条消息。但是，在我使用的Akka版本(2.4.6)中，在?类中没有ask或ActorRef类。
它是移到某个地方还是被废弃了？
浏览 3提问于2016-05-28得票数 4
回答已采纳
1回答
[error] DeviceAffiliationCluster.scala:56: value ask is not a member of akka.actor.ActorRef
[error] def ask(msg: Any): Future[Any] = deviceRegion.ask(msg)
[error] ^
[warn] DeviceAffiliationCluster.scala:5: Unused import
[warn] import akka.pattern.ask
浏览 2提问于2018-02-26得票数 0
回答已采纳
我正在尝试从AKKA演员那里获得回复，但我能够在Ask方法的帮助下获得回复
object mainTest {
val TestTypedSystem: ActorSystem[FuncTest.TypedFuncTest] = ActorSystem(FuncTest(),"FuncTest")
implicit val sc: Scheduler = TestTypedSystem.scheduler
implicit val ex: ExecutionContext = TestTypedSystem.executionContext
import
浏览 0提问于2020-06-07得票数 0
我有一个ActorSystem (例如A)，它生成其他ActorSystem(例如B)。当B出现时，它知道A的地址，并执行cluster.join()。一旦集群被加入，参与者就可以相互通信了。
在我的场景中：
我有一个REST请求来喷射框架来生成一个新的ActorSystem。
在请求处理程序中，我执行ask(?)到ActorSystem A
"A“收到消息，我存储了ask(?)的地址。向DB请求。它是一个临时演员，类似于"akka://ActorSystemA/ temp /$a“
"A“用ActorSystem "B”生成一个新的JVM
浏览 0提问于2018-02-20得票数 0
回答已采纳
最近，在Akka演员中创建的scala.concurrent.Future对象正在经历一些超时，我想知道如何处理这些超时事件。他们真的迷路了吗？它们是否被重新尝试并保存在记忆中，或者是如何工作的？
为了提供一些上下文，代码如下所示。
List<Future<MyMessage>> futureMessageList = plainMessages.stream()
.map(this::toFuture)
.collect(Collectors.toList());
Futures.sequence(futureMessageList, Exe
浏览 0提问于2020-04-14得票数 0
回答已采纳
3回答
使用Akka 2.0尝试向自己发送消息(使用ask模式)
import akka.pattern.ask
import scala.concurrent.{Await, Future}
import akka.actor.{Props, Actor, ActorSystem}
import scala.concurrent.duration._
import akka.util.Timeout
object askTest extends App{
implicit val timeout = Timeout(5 seconds)
val system = ActorSystem(
浏览 0提问于2014-03-11得票数 1
回答已采纳
1回答
我正在尝试理解akka-Testkit"，并希望可以询问它。
我找到了一些教程和博客，它们要么访问TestActorRef上underlyingActor上的状态属性，要么访问lastMsg属性。但是，来自"akka-testkit_2.11“% "2.4.10”的TestActorRef没有这些属性。我在akka网站上看了这个例子，也许我遗漏了一些东西，但他们展示了对回声演员的测试，但没有使用任何简单的演员实现。
那么，有没有人能帮我理解一下，如果n%3 == 0(本例中就是这种情况)，如何测试一个以相同数字响应的worker。如果可能的话，我不喜欢使用future和
浏览 9提问于2016-09-10得票数 2
回答已采纳
我有ParentActor和2个ChildActors，这是我的代码 Class ParentActor extends Actor {
val mongoActor = context.of.....
val esActor = context.of ............
def receive {
case InserInMongo(obj) =>
val mFuture = ask(mongoActor, InsertDataInMongo(object)).mapTo[Boolean]
mFuture.onComplete {
case Su
浏览 17提问于2019-02-19得票数 0
回答已采纳
我有一个控制器，ask在回答之前是一个参与者，还有两个测试用例：
当我运行play test时，第二个测试失败
当我运行play testOnly ApplicationSpec和play testOnly IntegrationSpec时，两者都成功了
我认为Akka系统在第一次测试中被关闭，而不是在第二次测试时再次启动，但为什么呢？我怎么才能解决这个问题呢？
控制员：
object Application extends Controller {
implicit val _ = Timeout(3 seconds)
val gamesManagerRef = Ak
浏览 1提问于2014-01-02得票数 9
回答已采纳
1回答
我得到了这个我不理解的编译错误：
[error] /Users/nicu/mooc-reactive/akkahttp-typed-actors-cluster-ORMap-followers/src/main/scala/followers/HttpServer.scala:43:76: type mismatch;
[error] found : akka.actor.typed.ActorRef[Res] => Req
[error] (which expands to) akka.actor.typed.ActorRef[scala.collection.immu
浏览 14提问于2020-02-11得票数 0
2回答
akka文件指出：
(...)您只需编写您的演员代码，而不必担心并发性。
在幕后，Akka将在一组实际线程上运行一组参与者，通常许多参与者共享一个线程，而随后对一个参与者的调用可能会在不同的线程上被处理。Akka确保此实现细节不会影响处理参与者状态的单一三重性。
但假设我正在构建一个未来，并在事件处理线程中将其导入回调。例如，使用ask模式：
ask(someActor, new SomeRequest(), timeout)
.onSuccess(new OnSuccess<Object>() {
@Override
浏览 1提问于2016-09-15得票数 1
回答已采纳
2回答
Akka中Ask超时的默认值是多少？
在Akka中使用ask方法所需要的就是导入akka.pattern.ask。在文档中，有这样的例子:在哪里不直接或作为隐式val提供超时。
我已经阅读了“问我自己”的源代码，无法找到为超时提供的默认值。但是，即使没有提供超时，ask方法也可以正常工作，这意味着在某个地方使用了默认值。
这个默认值是什么，它是如何提供的？
浏览 1提问于2019-03-05得票数 1
回答已采纳
2回答
我刚刚开始学习Scala的Akka库。我遇到了使用Ask模式从Actor获取响应的情况(就像启动线程来完成一些计算并得到结果一样)。
下面是我的代码，其中我使用了Ask模式，其中的超时阻止了它的执行。为什么？
import akka.actor._
import akka.routing._
import akka.util.Timeout
import akka.pattern.ask
import java.math.BigInteger
import java.time.LocalDate
import scala.concurrent.duration._
import scala.c
浏览 0提问于2015-01-03得票数 1
我正在做这样的事情：
...lots of surrounding context...
val actor = context.actorOf(Props(new Actor(...))
(actor ? message) onComplete {
case Done => {
println("done")
Do stuff with the surrounding context of this actor
}
case _ => {
println("got wildcard") // try to handl
浏览 0提问于2018-05-16得票数 1
我有这样的代码，在Scala中我正在发出一个问询请求：
implicit val result =system.actorOf(Props(new TestActor("TestingName")),name = "Scala")
val future3:Future[String]= ask(result ,Message).mapTo[String]
val results = Await.result(future3, 5 second)
这里是我的进口报表
import scala.concurrent.{Await, Future}
im
浏览 1提问于2017-07-05得票数 2
我是个初学玩的人，所以请容忍我。我试图让我的游戏控制器与我的后端Akka集群通信。html get请求被路由到我的Controller中的以下方法：
public CompletionStage<Result> createSession(int connectionId){
return FutureConverters.toJava(ask(shardRegion, new CreateSessionMessage(connectionId), 2000))
.thenApply(response -> ok((St
浏览 1提问于2019-04-25得票数 0
1回答
我对akka +的游戏框架很陌生。我已经在玩异步动作方法中使用了直接流畅的运行方法。跑(.)…)方法返回FutureT。现在我的问题是-在控制器中的play异步操作中使用参与者ask方法可以执行灵活的运行方法吗？
package controllers
import akka.actor.{ActorRef, ActorSystem, Props}
import akka.pattern.ask
import akka.util.Timeout
import javax.inject.{Inject, Singleton}
import play.api.mvc._
import servi
浏览 2提问于2019-01-31得票数 1
回答已采纳
2回答
下面是在Akka中使用调度的一个基本示例：
import akka.pattern
import akka.util.Timeout
import scala.concurrent.Await
import akka.actor.Actor
import akka.actor.Props
import akka.actor.ActorSystem
import akka.pattern.ask
import scala.concurrent.duration
object Application extends App {
val supervisor = ActorSystem().a
浏览 4提问于2013-07-26得票数 0
回答已采纳
我已经将喷雾客户端的示例代码复制到我自己的项目中，以使其易于获得。我使用IntelliJ 13。
下面是我的代码：
package mypackage
import scala.util.Success
import scala.concurrent.duration._
import akka.actor.ActorSystem
import akka.pattern.ask
import akka.event.Logging
import akka.io.IO
import spray.json.{JsonFormat, DefaultJsonProtocol}
import spray
浏览 6提问于2014-03-27得票数 2
回答已采纳
1回答
在实习面试中，我的朋友让我在规定的时间内与Scala演员实现合并排序。
代码最后看起来是这样的：
基本上，应用程序的启动方式如下：
import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.duration._
import akka.actor.ActorSystem
import akka.actor.{ActorRef, Props}
def main(args: Array[String]): Unit = {
val system = ActorSystem("CrappyA
浏览 0提问于2016-03-04得票数 0
我正在构建一些与Akka中的ask模式类似(但不完全相同)的东西，在Akka中，我需要实例化一个处理单个消息然后杀死自己的临时参与者。我使用actorOf()实现了每个请求一次的基本工作流，但这感觉不太正确，因为它每次都会在新的路径上注册一个新的参与者。
这样做的正确方法是什么？
浏览 0提问于2012-05-10得票数 6
2回答
如何使用Akka Actor ask和维护类型安全？或者避免使用ask而倾向于tells？
在Akka Actor上调用?或ask时，会返回一个Future[Any]，我必须通过future.mapTo[MyType]进行显式强制转换。
我不喜欢失去这个类型的安全性。如果我直接使用Futures (没有参与者)，我可以显式地返回Future[MyType]并维护类型安全。
我的特定用例涉及一个参与者将其消息委托给两个子参与者，然后聚合来自这两个参与者的结果，并将结果返回给父参与者的发送者。我父母的接收方法类似于Akka文档中的这种方法：
val f1 = actor1 ? msg
val f
浏览 14提问于2012-11-30得票数 17
回答已采纳
正如akka博士所描述的，akka会发送信息-忘了-。
但是在ask模式中，如果typekey不存在，我仍然需要等待响应使用超时。
在向不存在的typekey发送消息时，是否有一种立即失败的方法？
浏览 7提问于2022-11-25得票数 1
回答已采纳
我试图使用Akka演员在我的游戏2.5应用程序依赖注入。我基本上遵循了，下面是我的代码的一瞥：
演员
基本上，我有一个简单的参与者，它接收一些数据，处理数据，并将其发送回调用方。
package actors
import akka.actor._
import akka.pattern.{AskTimeoutException, ask}
import akka.util.Timeout
import javax.inject._
import com.google.inject.assistedinject.Assisted
import play.api.Configurat
浏览 8提问于2016-05-12得票数 3
1回答
我刚到阿克卡-Http。我添加了下面的路线
path(urlpath / "messages") {
post {
decodeRequest {
withoutSizeLimit {
entity(asSourceOf[Message]) { source =>
val storeToDb = Flow[Message].map[Future[Message]](message => (service ask message).mapTo[Mes
浏览 0提问于2019-06-20得票数 1
1回答
我想以一种控制发送到服务器的最大请求数的方式来配置喷雾http客户端。我需要这个，因为我正在发送请求的服务器阻止我，如果有超过2个请求被发送。我得到了
akka.pattern.AskTimeoutException: Ask timed out on [Actor[akka://smallTasks/user/IO-HTTP#151444590]] after [15000 ms]
akka.pattern.AskTimeoutException: Ask timed out on [Actor[akka://smallTasks/user/IO-HTTP#151444590]] after
浏览 6提问于2015-06-30得票数 1
假设我有一个IO Actor connection，能够通过TCP发送和接收消息。在我的演员中，我要求连接的另一方作出回应：
connection.ask(ByteString("stuff")).collect {
case Received(response) => log.debug(response.utf8String)
}
看起来，使用此代码，ask未来会超时，而包含的参与者则会在ask模式之外接收原始消息。
你能和Akka IO演员一起使用ask模式吗？若否，原因为何？
浏览 3提问于2014-05-09得票数 4
回答已采纳
1回答
我试图返回流操作的结果，在本例中是：
与列表之和
平方值
平方值
其表现为：
.fold(0, (aggr, next) -> aggr + next)
.map(x -> x * x)
.map(x -> x * x)
访问我使用的值
final AtomicInteger returnValue = new AtomicInteger();
其次是：
.to(Sink.foreach(x -> {
returnValue.set(x);
浏览 17提问于2021-04-12得票数 0
回答已采纳
1回答
我有一个错误的导入等待从akka.io。这是我的build.sbt：
name := "Project1"
version := "0.1"
scalaVersion := "2.10.1"
libraryDependencies += "org.json4s" %% "json4s-native" % "3.2.4"
resolvers += "Typesafe Repository" at "http://repo.typesafe.com/typesafe/re
浏览 1提问于2013-07-24得票数 4
回答已采纳
像这样，我有一个司机/主修班。(基本上我是想把风暴和AKKA混为一谈)。在TenderEventSpout2类中，我试图向参与者发送和接收消息。
public class TenderEventSpout2 extends BaseRichSpout {
ActorSystemHandle actorSystemHandle;
ActorSystem _system;
ActorRef eventSpoutActor;
Future<Object> future;
Timeout timeout;
浏览 0提问于2016-05-12得票数 0
回答已采纳
我从这里得到了上面的错误消息：
implicit val askTimeout = Timeout(60 seconds)
val workerFuture = workerContext actorSelection(payload.classname) resolveOne()
val worker = Await.result(workerFuture, 10 seconds)
worker ask Landau(List("1", "2", "3"))
特别是从第二行开始..所做的导入是
import akka.actor._
impor
浏览 5提问于2013-10-10得票数 3
下面是一个最小的例子
package org.example
import akka.actor._
import akka.pattern.ask
import akka.util.duration._
import akka.util.Timeout
class Counter extends Actor {
def receive = {
case _ => sender ! "hi"
}
}
object AkkaProjectInScala extends App {
val system = ActorSystem("Akk
浏览 0提问于2013-03-15得票数 1
回答已采纳
2回答
我正在学习Akka远程处理，指的是“学习Akka”一书。
使用有限的网络，我不能使用sbt (不能很好地配置代理)。
首先，我使用application.conf为Akka服务器创建一个项目
akka {
actor {
provider = remote
}
remote {
emabled-transports = ["akka.remote.netty.tcp"]
netty.tcp {
hostname = "127.0.0.1"
port = 2552
}
}
}
控制台显示
Re
浏览 2提问于2017-10-03得票数 0
1回答
Flink 1.5.3，当我向flink集群(在纱线上)提交flink作业时，它总是抛出AskTimeoutException。在flink配置文件中，我已经配置了参数"akka.ask.timeout=1000s“，但异常仍然如下所示。 这意味着我增加了超时参数"akka.ask.timeout=1000s“，但它不起作用。 org.apache.flink.runtime.rest.handler.RestHandlerException: Job submission failed.
at org.apache.flink.runtime.rest.handle
浏览 27提问于2018-12-22得票数 4
目前，我使用Akka参与者来建立一个代码块，该代码块以原子方式和线程安全的方式执行(Akka邮箱语义通过一次处理一条消息强制执行原子性)。
然而，这就引入了对参与者系统的需求，以及附加的副作用或膨胀(必须手动向调用方传播异常，在ask上失去类型安全性，并且通常使用消息语义而不是函数调用)。
一个线程安全的原子代码块能否以更简单的方式在scala中完成？你会把@volatile应用于一个函数吗？
浏览 1提问于2015-04-07得票数 0
回答已采纳
我使用use Akka并使用ask方法发送消息
val future: Future = actor ? msg
但当我试图将那个角色替换为PersistentActor with AtLeastOnceDeliveryLike时，未来永远不会完成，并因超时而倒下。
Akka Persistent Actor可以和ask方法一起使用吗？
浏览 0提问于2015-10-19得票数 2
1回答
Akka问询超时
、、
我们有一个akka/scala应用程序，它有一些我需要修复的天真的错误处理。
REST端点与进行远程调用以创建订单的内部参与者通信。
它使用ask进行此操作，当ask超时(例如由于网络或通信错误)时，我们通过REST端点向客户端发送请求失败的消息。
问题是内部参与者有自己的队列/重试逻辑，它将继续调用远程接口，直到请求成功。
因此，我们有这样的情况:我们已经告诉客户端请求失败了，但是它实际上只是排队(并且最终会成功)。客户重新提交请求，我们最终得到100份重复订单。
我的问题是:当询问请求超时时，akka是否支持回滚或毒害问询消息的通用方法？
浏览 3提问于2021-11-29得票数 0
回答已采纳
我正在尝试实现曼宁的"Akka in Action“一书中的"Up and Running" example的Java版本。它是一个简单的基于Actor模型的Http服务器，用于保存(仅在内存中)和检索一些事件。我对保存事件没有任何问题。但是在我的参与者系统中查询事件(所有事件)时，我确实遇到了一个问题。 这是所有TicketSeller的父参与者(后来负责管理每个事件的状态)的相关代码(我放了三个点，而不是我认为与我的问题无关的代码)。 public class BoxOffice extends AbstractActor {
...
priva
浏览 23提问于2019-03-04得票数 0
回答已采纳
我是Akka演员的新手，我做了一些实验来了解演员是如何工作的。
class RequestActor extends Actor with ActorLogging {
import RequestActor._
implicit val timeout = Timeout(15.seconds)
implicit val ec: ExecutionContext = context.dispatcher
override def receive: Receive = {
case Request(name) =>
// self ? TempReq
浏览 3提问于2019-11-19得票数 2
回答已采纳
1回答
我和Akka 2一起工作，玩2.0.2。我想把剧本Framewrok和一个远程的Akka系统连接起来。我已经完成了远程配置和对演员的远程引用，但是任何时候我都试图将播放框架连接到Akka远程系统。我得到错误，我提出了下面的代码片段。
游戏应用程序中的代码。
public static Result index() throws InterruptedException {
ActorSystem csystem = Akka.system();
ActorRef localNode = csystem.actorOf(new Props(LocalNode.clas
浏览 1提问于2012-10-01得票数 2
akka.pattern.AskTimeoutException的作业提交失败，我已尝试设置akka.ask.timeout: "60s"，但仍因相同的错误而失败。有什么想法吗？
akka.pattern.AskTimeoutException: Ask timed out on [Actor[akka://flink/user/dispatcher#-1594246162]] after [10000 ms]. Message of type [org.apache.flink.runtime.rpc.messages.LocalFencedMessage]. A typic
浏览 0提问于2019-11-08得票数 0
我的Monitoring的Actor层次结构看起来像
Monitor
/ \
Disk Memory
/ \
Remote Local
在哪里，Monitor要求它的子角色获取数据等等。最后，Monitor接收所有数据并将其打印到控制台上(例如)。
仅考虑到Memory层次结构，我意识到在ask模式中，层次结构中的调用如下所示
(内存级)
import ExecutionContext.Implicits.global
implicit val timeout = Timeout(5 seconds)
lpM
浏览 0提问于2015-08-19得票数 1
回答已采纳
我之前使用的是来自akka.contrib的TimerBasedThrottler，但现在已被弃用，取而代之的是akka stream throttle。这是我的演员
class MyActor extends Actor{
def receive = {
case Message(msg) =>
val date = LocalDateTime.now()
println(s"getting: $msg @ $date from ${sender()}")
sender() ! s"$ms
浏览 0提问于2017-07-31得票数 0
我尝试了一个使用MongoDb支持的akka持久化的"hello-world“示例，使用这个开源的。下面是我的密码。但是，当我运行应用程序时，我得到了ask超时：
akka.pattern.AskTimeoutException:要求在2000年后在[Actorakka://example/user/sampleActor#1876558089]上超时。发送"actors.Command".类型的消息
import akka.actor.{ActorSystem, Props}
import akka.pattern.ask
import akka.persistenc
浏览 2提问于2017-01-10得票数 0
下面是我的代码，在这里我得到了问题标题中的异常
ActorRef和这里的ask函数都是Akka，但是我不知道上面的异常是什么意思。即使是在谷歌上的搜索也不会在NotInferedB....can上产生太多信息，有人会给我们一些启示吗？
def exchangeRateLookup(exchangeRateActor: ActorRef): (Option) => Future[Any] = {
(iv: Option) => iv map (iv => ask(exchangeRateActor, iv.asInstanceOf[IV].getCurrency
浏览 5提问于2014-02-23得票数 2
1回答
我正在创建一个演员，我想第一次创建它，然后在需要该演员时使用它的参与者引用。这是代码
val actorPath = "akka://testActorSystem/user/'"
object ActorManager {
def getTestActorRef: ActorRef = {
var actorRef: Option[ActorRef] = None
this.synchronized {
val sel = system.actorSelection(actorPath + "testActor");
浏览 0提问于2018-03-29得票数 0
回答已采纳
1回答
我对阿克卡世界非常陌生，我不得不把一个项目从喷雾迁移到阿克卡-http。
在喷雾中，一条路线是Route = RequestContext ⇒ Unit型。
但在akka中，它是Route = RequestContext ⇒ Future[RouteResult]类型的.
因此，在喷雾中，我们经常通过一个演员链(主控制器之外)处理和完成我们的请求，只使用点火和遗忘，这样我们就不必“询问”了，而且性能也很好。现在，每当我们将请求传递给其他演员时，我们都必须使用“询问”(如果我错了，请纠正我)。
我已经搜索了很多，我发现了一些选项，我不确定它们是否完全满足了我(需要在另一个Actor中完成一个请
浏览 1提问于2016-12-18得票数 2
我们在当前项目中使用了akka.net角色模型。我使用了一个实体actor来处理对它的插入、更新和删除操作。在搜索或获取的情况下，角色模型是否不适合？
如果在UI中支持，如何获得结果(天气使用Ask函数)
使用akka.net参与者模型获取和查询数据不是很好的实践吗？
浏览 10提问于2017-03-16得票数 0
我是Akka的新手，我想通过Akka gRPC和集群切分创建一个分布式服务，它为客户端提供数据检索服务。
因此，一些RequestActor (我不确定，在gRPC中根本没有这样的参与者)接收到一个客户端请求，并通过shardRegion将其转发给另一个ProcessingActor以获得查询结果。
有两种选择：
tell模式
shardRegion ! Request(raw_request, localRequestActor)
ask模式
shardRegion ? raw_request pipeTo(localRequestActor)
我的问题是，
由于所有请求
浏览 0提问于2019-09-16得票数 0
回答已采纳
1回答
在进行Patterns.ask()调用时，我需要访问发送方参与者。示例：
ActorSystem system = ActorSystem.create("MySystem");
ActorRef actor = system.create(..., "MyActor");
Future<Object> futureResult = Patterns.ask(actor, new Question(), 10000);
在这里，Akka框架将向"MyActor"参与者发送一条消息，该角色必须通过：getSender().tell(..
浏览 3提问于2017-09-18得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
云直播活动推荐
腾讯云开发者
