web-dev-qa-db-ja.com

Akka / Scala：FutureとpipeToのマッピング

Akkaアクターには、Future結果を別のアクターに送信することの間で、使用されているスレッドの数、またはスレッドロックの点で、次のような違いがありますか？

A. Futureを関数にマッピングし、そのtell結果をアクターに送信します。

B.将来のonSuccessコールバックを定義し、その結果をtellアクターに送信します。

C. Future結果をpipeToを使用してアクターにパイプする。

これらのオプションのいくつかは、前の質問で説明されています。

アッカ：アクターに今後のメッセージを送信

3つのうちどれが好ましい方法であり、その理由は何ですか？

また、receiveがAny => Unit型である必要がある場合、なぜreceiveの部分関数がFutureではなくUnitを返す場合にコードがコンパイルされるのですか？

上記の3つのオプションのコード例を次に示します。

import akka.actor.{Actor, ActorRef, ActorSystem, Props}
import akka.pattern.ask
import akka.util.Timeout
import akka.pattern.pipe

import scala.concurrent.Future
import scala.concurrent.duration._
import scala.language.postfixOps
import scala.util.Success

class ActorIncrement extends Actor {

  def receive = {
    case i: Int =>
      println(s"increment $i")
      sender ! i + 1
  }
}

class ActorEven extends Actor {

  def receive = {
    case i: Int =>
      println(s"$i is even")
  }
}


class ActorOdd extends Actor {

  def receive = {
    case i: Int =>
      println(s"$i is odd")
  }
}

class MyActor(actorIncrement: ActorRef, actorEven: ActorRef, actorOdd: ActorRef) extends Actor {
  import scala.concurrent.ExecutionContext.Implicits.global

  implicit val timeout = Timeout(5 seconds)

  def receive = {
    case i: Int if i % 2 == 0 =>
      println(s"receive a: $i")
      actorIncrement ? i map {
        case j: Int =>
          println(s"$j from increment a")
          actorOdd ! j
      }
    case i: Int =>
      println(s"receive b: $i")
      val future: Future[Any] = actorIncrement ? i
      future onSuccess {
        case i: Int =>
          println(s"$i from increment b")
          actorEven ! i
      }

    case s: String =>
      println(s"receive c: $s")
      (actorIncrement ? s.toInt).mapTo[Int] filter(_ % 2 == 0) andThen { case Success(i: Int) => println(s"$i from increment c") } pipeTo actorEven
  }
}

object TalkToActor extends App {

  // Create the 'talk-to-actor' actor system
  val system = ActorSystem("talk-to-actor")

  val actorIncrement = system.actorOf(Props[ActorIncrement], "actorIncrement")
  val actorEven = system.actorOf(Props[ActorEven], "actorEven")
  val actorOdd = system.actorOf(Props[ActorOdd], "actorOdd")

  val myActor = system.actorOf(Props(new MyActor(actorIncrement, actorEven, actorOdd)), "myActor")

  myActor ! 2
  myActor ! 7
  myActor ! "11"

  Thread.sleep(1000)

  //shutdown system
  system.terminate()
}
scalaakkaactor
13
rapt

pipeToがakka.pattern.PipeToSupportでどのように定義されているかを見ると、

def pipeTo(recipient: ActorRef)(implicit sender: ActorRef = 
  Actor.noSender): Future[T] = {
    future andThen {
      case Success(r) ⇒ recipient ! r
      case Failure(f) ⇒ recipient ! Status.Failure(f)
    }
  }
}

ご覧のとおり... pipeToは、andThen呼び出しをFutureに追加するだけで、future-resultまたはStatus.Failureメッセージを送信します。 Futureが失敗した場合のパイプされたアクター.

現在の主な違いは、このStatus.Failureの障害処理にあります。 pipeToを使用していない場合は、失敗を任意の方法で処理できます。

13
Sarvesh Kumar Singh