如何知道一个演员系统中是否存在一个演员

Question

嗨，我想在一个actor系统中创建一个actor，如果尚未在此处创建它就是我的代码

val sel = actorSystem.actorSelection("akka://ActorSystem/user/ReadOnlyAdminIndexMongoActor");
val asker = new AskableActorSelection(sel);

val future = asker.ask( Identify(1),Timeout(30 seconds))
val identity=Await.result(future, timeout.duration).asInstanceOf[ActorIdentity]         

val reference = identity.getRef
if(reference != null){
     log.info("actor does not exists")
   }
   else
   {
     log.info("actor exists"+sel.toString())
   }

但是这段代码抛出异常

17:00:19.547 1822010 [ArteciateActorSystem-akka.actor.default-dispatcher-7] EmptyLocalActorRef INFO - Message [scala.Tuple2] from Actor[akka://ActorSystem/temp/$e] to Actor[akka://ActorSystem/user/ReadOnlyAdminIndexMongoActor] was not delivered. [5] dead letters encountered. This logging can be turned off or adjusted with configuration settings 'akka.log-dead-letters' and 'akka.log-dead-letters-during-shutdown'.
java.util.concurrent.TimeoutException: Futures timed out after [30 seconds]
    at scala.concurrent.impl.Promise$DefaultPromise.ready(Promise.scala:219)
    at scala.concurrent.impl.Promise$DefaultPromise.result(Promise.scala:223)
    at scala.concurrent.Await$$anonfun$result$1.apply(package.scala:190)
    at scala.concurrent.BlockContext$DefaultBlockContext$.blockOn(BlockContext.scala:53)
    at scala.concurrent.Await$.result(package.scala:190)
    at models.Global$.checkActor(Global.scala:71)

这是第71行的代码

val identity=Await.result(future, timeout.duration).asInstanceOf[ActorIdentity]   

请帮我在哪里，我错了，并且还我使用从这个这个代码链接 ，该链接的代码givein在接受的答案

Answer 1

使用“ Identify是Identify是否存在的正确方法。 接收到询问超时通常表明它没有，因为那里没有参与者响应。 我之所以这么说， 是因为消息流量的负载和/或远程处理可能由于其他原因而导致超时。

我的问题是，既然您有一个众所周知的地址，那么在什么情况下该演员可能不存在？ 您是否只是想按需懒惰地创建它，还是想从演员的崩溃中恢复？

对于这两种情况，我都建议使用一种代理模式，即在众所周知的地址处放置一个简单的，防崩溃的（由于其简单性）actor，该actor负责按需创建ReadOnlyAdminIndexMongoActor并向其代理消息。 该代理也将是主管，在崩溃时恢复演员。 如果可以的话，它甚至允许您使ReadOnlyAdminIndexMongoActor超时，因为每个人都将始终通过代理与之对话。

此代理的简单实现（没有主管或空闲超时处理）可能类似于：

class OnDemandProxyActor(proxyProps: Props) extends Actor {

  def receive = waiting()

  def waiting: Receive = {
    case msg =>
       val target = context.actorOf(proxyProps)
       target forward msg
       context.become(proxying(target))
  }

  def proxying(target: ActorRef): Receive = {
    case msg => target forward msg
  }
}

其中proxyProps是Props创造您的需求，演员， waiting是在没有消息被接收，因此代理的初始状态target尚未创建， proxying的是之后的状态target是创建。 两种状态都使用forward将接收到的消息发送到target ，就好像它是来自原始sender 。