Come aspettare che il sistema di attori Akka termini?

Question

Ho bisogno di avviare il sistema di attori Akka (2.0), inviare alcuni messaggi, quindi attendere che faccia il sollevamento pesi. Dopodiché, ho bisogno di fare qualcosa che non sia correlato a quegli attori.

ho cercato di aspettare che tutti gli attori a smettere con seguente codice:

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

Tutti gli attori si uccidono via self ! PoisonPill. Che cosa sto facendo di sbagliato?

Answer 1

ho trovato la soluzione - basta chiamare system.shutdown dal master attore:

context.system.shutdown 

Answer 2

Si può anche uccidere il ActorSystem dal thread principale utilizzando system.shutdown. Ma quell'operazione è asincrona. Hai solo bisogno di usare system.awaitTermination se hai bisogno di bloccare il thread principale fino al suo completamento. Se i tuoi parallelRunner restituiscono qualcosa di utile per il resto del programma, probabilmente sarebbe più semplice non bloccare e continuare il tuo programma.

Answer 3

A partire da Akka 2.4, è necessario utilizzare system.awaitTermination() che restituisce un Future[Terminated] che è possibile attendere.

Al fine di porre fine al sistema, è necessario utilizzare ActorSystem.terminate (ad es context.system.terminate() dall'interno di un attore quando è finito

Fonte:. Release Notes

Answer 4

In Akka 2.4.1 per Scala 2.11 sembra essere ancora una volta diversa.

system.awaitTermination() è deprecato e la documentazione ci istruiscono da usare Await.result(system.whenTerminated, timeout) invece.

Come 203 ha detto, system.terminate è ancora il modo per terminare il sistema.

Ecco qualche esempio di codice che ho usato:

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)) 

Poi nella classe MyActor ho la linea di context.system.terminate()

Answer 5

in Akka 2.3.9, sembra che l'arresto di un sistema di attore e in attesa di per arrestare è un processo in due fasi:

1. avviino l'arresto: actorSystem.shutdown
2. Attendere sua terminazione in maniera bloccante: actorSystem.awaitTermination

Come alternativa allo stadio (2), eventualmente (non hanno testato queste alternative) si possono in alternativa polling su isTerminated o utilizzare registerOnTermination per l'esecuzione del codice quando è terminato. Vale quindi la pena analizzare i commenti di akka.actor.ActorSystem e scegliere tra questi metodi per la propria implementazione.

Forse mi mancano altre opzioni sull'API (?) Come valori di ritorno Future potrebbero essere stati più belli.

Answer 6

Solo una nota a margine per chi si imbatte in questa domanda per il suo titolo: Apparentemente, Akka 2.5 non supporta più actorSystem.awaitTermination. La ragione è perché potrebbe essere la filosofia di Akka di evitare qualsiasi blocco delle chiamate. Invece, actorSystem.registerOnTermination(...) può essere utilizzato come metodo non bloccante per eseguire azioni mentre è in corso lo spegnimento di ActorSystem.

Tuttavia, si può ancora aspettare per il vostro sistema attore per completare attraverso un Future fornito da 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) 

Answer 7

ne dite:

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

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

terminare restituisce un futuro:

def terminate(): Future[Terminated] 

e puoi solo aspettare il completamento di questo futuro.