Akka: comunicare al di fuori del sistema dell'attore?

Question

Ho il seguente/classe principale driver di incapsulare il mio programma di Akka:

// Groovy pseudo-code 
class FizzBuzz { 
    ActorSystem actorSystem 

    static void main(String[] args) { 
     FizzBuzz d = new FizzBuzz() 
     d.run() 
    } 

    void run() { 
     Initialize initCmd = new Initialize() 
     MasterActor master = actorSystem.get(...) 

     // Tells the entire actor system to initialize itself and start doing stuff. 
     // ChickenCluckDetector is an actor managed/supervised by MasterActor. 
     master.tell(initCmd, ...) 
    } 

    // Called when a ChickenCluckDetector actor inside the actor system receives 
    // a 'Cluck' message. 
    void onChickenGoesCluck(Cluck cluck) { 
     // Do something 
    } 
} 

E la seguente ChickenCluckDetector attore:

class ChickenCluckDetector extends UntypedActor { 
    @Override 
    void onReceive(Object message) { 
     if(message instanceof Cluck) { 
      Cluck cluck = message as Cluck 

      // Now, how to pass the message safely/properly to FizzBuzz#onCluck? 
     } 
    } 
} 

Quindi il problema a portata di mano è come in modo sicuro/passare correttamente il messaggio Cluck a FizzBuzz#onCluck(Cluck), che vive fuori il sistema di attore? Ho potrebbe fornire un riferimento FizzBuzz-ChickenCluckDetector in questo modo:

class ChickenCluckDetector extends UntypedActor { 
    FizzBuzz fizzBuzz 

    @Override 
    void onReceive(Object message) { 
     if(message instanceof Cluck) { 
      Cluck cluck = message as Cluck 

      fizzBuzz.onCluck(cluck) 
     } 
    } 
} 

Ma ho la sensazione che questo viola le migliori pratiche di Akka e potrebbe causare ogni sorta di problemi di concorrenza a base, soprattutto se una sola FizzBuzz c'è (che c'è) non-attore/autista e diecimila attori ChickenCluckDetector. Idee?

Answer 1

se c'è solo un FizzBuzz (che non c'è) non-attore/pilota, e decine di migliaia di attori ChickenCluckDetector

Allora sarebbe meglio per creare un genitore comune per tutti questi ChickenCluckDetectors. Questo genitore potrebbe quindi mantenere in sicurezza il riferimento a FizzBuzz, ricevere cluck da tutti i suoi figli e chiamare il metodo onCluck.

Una richiesta per ottenere messaggi al di fuori degli attori è chiedere. E in Scala c'è l'attore DSL (aggiunto solo per completezza). Ma credo che non hai bisogno di nessuno di questi nel tuo esempio.

public class ChickenCluckMaster extends UntypedActor { 

    private FizzBuzz fizzBuzz; 

    public ChickenCluckMaster(FizzBuzz fizzBuzz) { 
     this.fizzBuzz = fizzBuzz; 
    } 

    public void onReceive(Object message) throws Exception { 
     if (message instanceOf CreateDetector) { 
      getContext().actorOf(
       Props.create(ChickenCluckDetector.class, getSelf); // Create child 
     } else if (message instanceof Cluck) { 
      fizzBuzz.onCluck(cluck); 
     } else { 
      unhandled(message); 
     } 
    } 

} 

public class ChickenCluckDetector extends UntypedActor { 

    private ActorRef master; 

    public ChickenCluckDetector(ActorRef master) { 
     this.master = master; 
    } 

    public void onReceive(Object message) throws Exception { 
     if (message instanceof Cluck) { 
      Cluck cluck = (Cluck) message; 
      master.tell(cluck, getSelf); 
     } else { 
      unhandled(message); 
     } 
    } 

}