Akka: komunikowanie się z powrotem poza systemem aktora?

Question

Mam następujący sterownik/główne klasy zamykającą mój program 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 
    } 
} 

i następujący ChickenCluckDetector Aktor:

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? 
     } 
    } 
} 

Więc problem pod ręką jest jak bezpiecznie/właściwie przekazać wiadomość Cluck do FizzBuzz#onCluck(Cluck), , który mieszka poza systemem aktorskim pod numerem? I mógłby zapewnić FizzBuzz odniesienie do ChickenCluckDetector tak:

class ChickenCluckDetector extends UntypedActor { 
    FizzBuzz fizzBuzz 

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

      fizzBuzz.onCluck(cluck) 
     } 
    } 
} 

Ale mam wrażenie ten jest niezgodny z najlepszych praktyk Akka i może spowodować wszelkiego rodzaju problemów współbieżności oparte, szczególnie jeśli istnieje tylko jeden FizzBuzz (co nie ma) aktor/kierowca i dziesięć tysięcy aktorów ChickenCluckDetector. Pomysły?

Answer 1

jeśli istnieje tylko jedna FizzBuzz (co tam jest), non-aktor/sterownik, a dziesięć tysięcy ChickenCluckDetector aktorów

Wtedy najlepiej byłoby stworzenie jednego wspólnego rodzica dla wszystkich tych ChickenCluckDetectors. Ten rodzic mógł następnie bezpiecznie przechowywać referencje do FizzBuzz, otrzymywać crypki od wszystkich swoich dzieci i wywoływać metodę onCluck.

Jedna z opcji uzyskiwania wiadomości poza aktorami. A w Scali jest aktor DSL (dodany tylko dla kompletności). Ale wierzę, że nie potrzebujesz żadnego z nich w swoim przykładzie.

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

}