如何使用Scala编写的Actor系统从未来获取数据？

Question

I have an Actor say ProcessTheCommand actor which has a receive method implemented as below:

class ProcessTheCommand extends Actor {
   def receive = {
     case obj: DataObject => 
       val f1 = OneActor ? obj
       val f2 = SecondActor ? obj
       // val result= resultFromf1 + resultFromf2
       // do something using the result
   }
}

My problem: How do i get the data out of the two futures?

One way to do it is to use await but that is not the best practice. Suggestions?

Answer 1

There are two parts to the question. The first is how to extract two futures and add them together, and the second one is how we process the result of these futures in Akka.

Composing Futures:

There a couple of ways. I'm assuming the results of the futures is the same. One would be using for comprehension:

val firstFuture: Future[Int] = ???
val secondFuture: Future[Int] = ???
val result: Future[Int] = for {
  first <- firstFuture
  second <- secondFuture
} yield first + second

Another option would be to use Future.sequence :

val firstFuture: Future[Int] = ???
val secondFuture: Future[Int] = ???

val result: Future[Int] = Future
  .sequence(Seq(firstFuture, secondFuture))
  .map {
    results => results.sum
  }

Another would be zip with map (thanks @ViktorKlang):

firstFuture
 .zip(secondFuture)
 .map { case (first, second) => first + second }

Or with Scala 2.12 zipWith :

val result: Future[Int] = firstFuture.zipWith(secondFuture) {
  case (first, second) => first + second
}

Extracting the value inside the Actor:

The only missing piece is how we get the accumulated result. The pattern in Akka is to pipe the result to your own Receive , since we never want to block on the method call, what we actually want is the future to invoke a callback once it completes, which is exactly what pipeTo will do.

We'll create a custom case class which encapsulates the result:

case class AccumulatedResult(result: Int)

And add it in Receive :

import akka.pattern.pipe
override def receive: Receive = {
  case obj: DataObject => 
    val firstFuture = OneActor ? obj
    val secondFuture = SecondActor ? obj
    firstFuture
     .zip(secondFuture)
     .map { case (first, second) => AccumulatedResult(first + second) }
     .pipeTo(self)

  case AccumulatedResult(res) => println(res)
}

The nice thing about this is that once the future completes the handling of the message will continue as part of the flow handling logic of the actor.

Answer 2

Blocking inside receive method is a big NO, so never use await inside receive , otherwise you'll starve on resources. All message processing happens in just a couple of worker threads.

To handle two futures, you might want to use their monadic properties:

val result: Future[Int] = firstFuture.flatMap { firstValue => 
   secondFuture.flatMap { secondValue => 
      firstValue + secondValue
   }
}

Or same thing via for-comprehension:

val result: Future[Int] = for {
  fistValue <- firstFuture
  secondValue <- secondFuture
} yield firstValue + secondValue

However, this is not what you usually want in actors, because you still get a Future and would need to block until it's completed. What you usually want is to pass the value to the caller or the next actor. And for this you can use pipe pattern:

import akka.pattern.pipe
val resultFuture: Future[Int] = for {
  fistValue <- firstFuture
  secondValue <- secondFuture
} yield firstValue + secondValue
resultFuture pipeTo sender() // sends result to the sender when future is completed

See also: Futures in Akka