在将来包装时可以使用阻塞参与者消息吗？

Question

我现在的应用是基于akka 1.1的。它有多个ProjectAnalysisActors，每个都负责处理特定项目的分析任务。当这样的参与者接收到通用开始消息时，分析就开始了。在完成一个步骤之后，只要定义了一个步骤，它就会向自己发送一条包含下一步的消息。执行代码基本上如下所示

sealed trait AnalysisEvent {
   def run(project: Project): Future[Any]
   def nextStep: AnalysisEvent = null
}

case class StartAnalysis() extends AnalysisEvent {
   override def run ...
   override def nextStep: AnalysisEvent = new FirstStep
}

case class FirstStep() extends AnalysisEvent {
   override def run ...
   override def nextStep: AnalysisEvent = new SecondStep
}

case class SecondStep() extends AnalysisEvent {
   ...
}

class ProjectAnalysisActor(project: Project) extends Actor {

    def receive = {
        case event: AnalysisEvent =>
            val future = event.run(project)
            future.onComplete { f =>
                self ! event.nextStep
            }
    }

}

我在如何为每个分析步骤的run-method实现代码时遇到了一些困难。目前，我在每个run-method中创建了一个新的未来。在这个未来，我会将所有后续消息发送到不同的子系统。它们中的一些是非阻塞的fire-and-forget消息，但其中一些返回的结果应该在下一个分析步骤开始之前存储。

目前，典型的run-method如下所示

def run(project: Project): Future[Any] = {
    Future {
        progressActor ! typicalFireAndForget(project.name)
        val calcResult = (calcActor1 !! doCalcMessage(project)).getOrElse(...)

        val p: Project = ... // created updated project using calcResult

        val result = (storage !! updateProjectInformation(p)).getOrElse(...)
        result
    }
}

由于这些阻塞消息应该被避免，我想知道这是不是正确的方式。在这种用例中使用它们是否有意义，或者我仍然应该避免使用它们？如果是这样的话，什么是正确的解决方案？

Answer 1

显然，ProjectAnalysisActor的唯一目的是链接未来的调用。其次，runs方法似乎也在等待结果来继续计算。

因此，我认为您可以尝试重构您的代码以使用未来的组合，如下所述：http://akka.io/docs/akka/1.1/scala/futures.html

def run(project: Project): Future[Any] = {
  progressActor ! typicalFireAndForget(project.name)
  for( 
      calcResult <- calcActor1 !!! doCalcMessage(project);
      p = ... // created updated project using calcResult
      result <- storage !!! updateProjectInformation(p)
  ) yield (
    result
  )
}