Comment attendre la fin du système d'acteur Akka?

Je besoin pour commencer à Akka (2.0), acteur du système, envoyer des messages, puis d'attendre pour elle de le faire soulever des objets lourds. Après cela, j'ai besoin de faire quelque chose sans rapport avec ces acteurs.

J'ai essayé d'attendre que tous les acteurs de l'arrêt de code suivant:

val system = new ActorSystem("parallelRunners")
val master = system.actorOf(Props[Master])
master ! Start
system.awaitTermination //<-- hangs here

Tous les acteurs de tuer eux-mêmes, par self ! PoisonPill. Ce que je fais mal?

source d'informationauteur Rogach

  1. 19

    Dans Akka 2.4.1 pour scala 2.11 il semble être encore différent.

    system.awaitTermination() est obsolète et les docs nous demander d'utiliser Await.result(system.whenTerminated, timeout) à la place.

    Comme Deux cent trois dit, system.terminate est encore le moyen de mettre fin au système.

    Voici un exemple de code que j'ai utilisé:

    val actorSystem = ActorSystem("ActorSystem")
val myActors = actorSystem.actorOf(Props[MyActor].withRouter(RoundRobinPool(10)), "MyActors")
rainbows.foreach(rainbow => myActors ! rainbow)
Await.ready(actorSystem.whenTerminated, Duration(1, TimeUnit.MINUTES))

    Puis dans le MyActor classe j'ai la ligne context.system.terminate()

  2. 6

    Comme d'Akka 2.4, vous devez utiliser system.awaitTermination() qui renvoie une Future[Terminated] vous pouvez attendre.

    Afin de mettre fin au système, vous devez utiliser ActorSystem.terminate (par exemple context.system.terminate() sein d'un acteur quand il est fini.

    Source: Notes De Version

  3. 4

    J'ai trouvé la solution - tout système d'appel.l'arrêt de la maîtrise de l'acteur:

    context.system.shutdown
  4. 4

    Vous pouvez également tuer les ActorSystem depuis le thread principal en utilisant system.shutdown. Mais ce fonctionnement est asynchrone. Vous avez seulement besoin d'utiliser system.awaitTermination si vous avez besoin de bloquer le thread principal jusqu'à la fin. Si votre parallelRunners retour quelque chose d'utile pour le reste du programme, alors il serait probablement plus facile de ne pas bloquer et de continuer votre programme.

  5. 3

    Juste une note de côté pour ceux en cours d'exécution dans cette question pour son titre: Apparemment, Akka 2.5 ne prend pas en charge actorSystem.awaitTermination plus. Raison pourquoi, peut-être Akka philosophie d'éviter tout blocage des appels. Au lieu de cela, actorSystem.registerOnTermination(...) peut être utilisé comme un non-blocage de la façon de faire des gestes tout en un ActorSystem est en cours d'arrêt.

    Néanmoins, vous pouvez toujours attendre pour que votre acteur du système à remplir par l'intermédiaire d'un Future fournis par ActorSystem.whenTerminated:

    val system = new ActorSystem("parallelRunners")
val master = system.actorOf(Props[Master])
master ! Start

import scala.concurrent.Await
import scala.concurrent.duration._
Await.ready(system.whenTerminated, 365.days)
  6. 0

    dans Akka 2.3.9, il semble que l'arrêt d'un acteur du système et l'attente à l'arrêt est un processus en deux étapes:

    1. Lancer la mise à l'arrêt:
      actorSystem.shutdown
    2. Attendre sa fin dans un blocage de la manière suivante:
      actorSystem.awaitTermination

    Comme une alternative à l'étape (2), peut-être (n'ai pas testé ces solutions de rechange) vous pouvez également sondage sur isTerminated ou de l'utilisation registerOnTermination pour l'exécution de code quand il est terminé. Alors, il vaut la peine de parcourir les commentaires de akka.de l'acteur.ActorSystem à comprendre et à choisir entre ces deux méthodes de mise en œuvre.

    Peut-être que je suis en manque d'autres options à propos de l'API (?) comme Future valeurs de retour aurait été plus agréable.

  7. 0

    Comment sur:

    import scala.concurrent.Await
import scala.concurrent.duration._

Await.ready(system.terminate(), 5.seconds)

    résilier renvoie un Futur:

    def terminate(): Future[Terminated]

    et vous pouvez simplement attendre la fin de cet avenir.