Scala 如何使用；询问；在阿克卡有三个值

我有一个演员，他向三个演员发送消息，并等待所有三个演员的响应，以便继续。 参与者返回表单的数据类型：List[（String，Double，String）]。 我希望它们都按照Tuple3的双精度值排序

到目前为止，我编写的代码是：

implicit val timeout = Timeout(5.seconds)
  val x = actorOne ? "hey"
  val y = actorTwo ? "you"
  val z = actorThree ? "there"
  val answer = for{
    a <- x.mapTo[List[(String, Double, String)]]
    b <- y.mapTo[List[(String, Double, String)]]
    c <- z.mapTo[List[(String, Double, String)]]
  } yield a ++ a ++ a sortBy(_._2)

implicit val timeout=超时（5秒）
val x=阿克特罗内？“嘿”
val y=actorTwo？“你”
val z=ActorTree？“那里”
val应答=用于{
a只有在评估a、b和c之后，你的理解能力才会得到评估，因此你不必在那里做任何事情。如果你的意思是你有一些取决于答案值的后续内容，那么你可以将其放入onComplete中：

answer.onComplete {
  case Success(x) => // do something on success
  case Failure(ex) => // report failure
}

您可以使用Promise在正确的时间与结果交互。例如，如果您的外部方法应该返回Future[Boolean]，您可以这样做：

def myFunction():Future[Boolean] = {
  val p = Promise[Boolean]
  implicit val timeout = Timeout(5.seconds)
  val x = actorOne ? "hey"
  val y = actorTwo ? "you"
  val z = actorThree ? "there"
  val answer = for{
    a <- x.mapTo[List[(String, Double, String)]]
    b <- y.mapTo[List[(String, Double, String)]]
    c <- z.mapTo[List[(String, Double, String)]]
  } yield a ++ a ++ a sortBy(_._2)
  answer.onComplete {
    case Success(x) => 
       // do something with x
      p.success(true)
    case Failure(ex) =>
       // process faliure
      p.success(false)
  }
  p.future
}

def myFunction（）：Future[Boolean]={
val p=承诺[布尔值]
隐式val超时=超时（5秒）
val x=actorOne？“嘿”
val y=actorTwo“你”
val z=ActorTree？“那里”
val应答=用于{
a此代码打印结果列表：

List((b1,2.03,b1), (c0,3.5,c0), (c0,3.5,c0), (b0,4.03,b0), (a0,4.1,a0), (a1,4.31,a1))

到stdout（您在代码的屈服部分中使用了三次“a”）

你说的“演员在三个演员都做出反应之前不会继续”到底是什么意思


参与者应该等待示例代码中的结果完成
参与者应该“隐藏”所有传入消息，直到结果可用


导入scala.concurrent.{Future，wait}
导入scala.concurrent.duration_
导入akka.util.Timeout
导入scala.concurrent.ExecutionContext.Implicits.global
隐式val超时=超时（5秒）
val x=未来（列表（（“a0”，4.1，“a0”），（“a1”，4.31，“a1”））
val y=未来（列表（（“b0”，4.03，“b0”），（“b1”，2.03，“b1”））
val z=未来（列表（（“c0”，3.5，“c0”），（“c0”，3.5，“c0”））
val应答=用于{
a是否必须使用“询问”模式？我认为标准的基于参与者的方法会更清晰。如果你愿意，我可以写下来。这很简单：）有没有其他方法可以在不使用for语句的情况下连接x、y、z的结果？例如“val answer=x++y++zYou可以使用scalaz的
msuml
，类似于
val answer=List（x，y，z）。msuml
（假设正确的隐式在范围内-我假设scalaz为
List
定义了一个合适的
PlusEmpty
实例）。请注意，虽然更复杂的流可能需要一个
承诺
，但像本例这样的简单结果转换可能会使用
answer.map
（可能与
.recover
结合使用）表达得更清楚。
  import scala.concurrent.{Future, Await}
  import scala.concurrent.duration._
  import akka.util.Timeout
  import scala.concurrent.ExecutionContext.Implicits.global


  implicit val timeout = Timeout(5.seconds)
  val x = Future(List(("a0", 4.1, "a0"), ("a1", 4.31, "a1")))
  val y = Future(List(("b0", 4.03, "b0"), ("b1", 2.03, "b1")))
  val z = Future(List(("c0", 3.5, "c0"), ("c0", 3.5, "c0")))
  val answer = for{
    a <- x.mapTo[List[(String, Double, String)]]
    b <- y.mapTo[List[(String, Double, String)]]
    c <- z.mapTo[List[(String, Double, String)]]
  } yield a ++ b ++ c sortBy(_._2)

  // don't use the result -> execute a side effect
  answer.foreach { res =>
    println(res)
  }


  // !!ONLY FOR TESTING!!
  Await.result(answer, 1.minute)
  Thread.sleep(1000)