Acteur AKKA autonome appelant recevoir activement

Question

Je veux mettre en œuvre des modèles de communication avancés avec akka 2.1. Cependant, akka semble différer des acteurs de Scala dans un aspect clé. Là où les acteurs de scala me permettent d'appeler activement "recevoir" et fournir une fonction partielle, les acteurs d'akka adoptent le principe hollywoodien "ne nous appelle pas, nous vous appellerons" et ne définissons qu'une fonction de réception de manière statique.

Dans les acteurs de scala, je pourrais avoir un motif comme celui-ci:

class MyActor extends Actor{ 

    override def act(){ 
    val x = expensiveFunc() 
    friend ! x 
    val y = receive { 
     case Answer(a) => println(a) 
    } 
    } 

} 

Ici, je fais explicitement les appels à recevoir. La raison en est que j'ai besoin d'acteurs autonomes qui exécutent chacun un programme SPMD et communiquent à des points spécifiques de l'exécution. Est-il possible d'émuler ce modèle en utilisant AKKA de manière significative?

---

EDIT je suppose qu'il est juste de donner un aperçu complet sur mon problème.

J'ai besoin de créer un programme SPMD en utilisant des acteurs. Cela signifie que je dois être en mesure de définir un comportement pour les acteurs qui est pas seulement réactif, c'est-à-dire que je dois être en mesure d'implémenter act() comme dans les anciens acteurs de la scala. En outre, je dois appeler explicitement recevoir (p: PartialFunction [T, U]) comme je pouvais le faire dans les anciens acteurs de la scala. Si je peux faire les deux choses ci-dessus, je serai en mesure de porter mon programme SPMD des anciens acteurs vers les acteurs Akka. Je soupçonne cependant qu'il n'est pas possible de mettre en œuvre une méthode d'acte en raison du motif hollywoodien (http://en.wikipedia.org/wiki/Hollywood_principle) que AKKA semble adopter.

EDIT2 Je crois que le problème pourrait recevoir actif être résolu par devenir/quelque chose comme-devenu ceci:

import context._ 
    def receive(p:PartialFunction[Any,Unit]){ 
    become(p) 
    receive() 
    unbecome() 
    } 

Cependant, cela exige que les appels imbriqués pour recevoir sont autorisés. Il y a une chance que je puisse imiter l'acte méthode en envoyant simplement un message comme:

case class Act(b:()=> Unit) extends Serializable 

qui encapsule alors le comportement que je voudrais que mon acteur à effectuer.

Answer 1

Vous pouvez avoir un certain contrôle sur votre boîte aux lettres à l'aide Stash:

http://doc.akka.io/docs/akka/2.1.0/scala/actors.html#Stash

Answer 2

Les acteurs Akka sont axés sur les événements. Chaque fois qu'un message est prêt à être consommé par la boîte aux lettres des acteurs, la fonction partielle définie dans recevoir dans l'acteur est appelée avec le message transmis.

En d'autres termes, "recevoir" n'est pas une construction impérative, vous ne pouvez pas l'appeler. attendre le prochain message. Ce que vous voulez est réalisable par le passage de message normal. L'acteur demandeur envoie les données à l'acteur travailleur, qui exécute l'opération coûteuse, puis renvoie la réponse.