Modèle pour les boucles interruptibles utilisant des acteurs

Question

Je suis en train de concevoir un acteur qui consomme des éléments à partir d'un flux infini et qui a besoin d'un moyen de contrôler quand il démarre et arrête d'utiliser des messages. Existe-t-il un modèle commun pour implémenter des boucles interruptibles comme celle-ci avec les acteurs? Je pensais juste à ce que mon acteur envoie des messages à lui-même. Quelque chose comme (pseudo Scala):

class Interruptible extends Actor { 
    val stream: Stream 
    val running: boolean 

    def receive = { 
    case "start" => { 
     running = true 
     consumeItem 
    } 

    case "stop" => { 
     running = false 
    } 

    case "consumeNext" => consumeItem 
    } 

    def consumeItem { 
    if (running) { 
     stream.getItem 
     this ! "consumeNext" 
    } 
    } 
} 

Est-ce la meilleure façon de faire les choses?

Merci!

Answer 1

Peut-être encodées comme ceci:

class Interruptible extends Actor { 
    val stream: Stream 

    def inactive: Receive = { // This is the behavior when inactive 
    case "start" => 
     self become active 
    } 

    def active: Receive = { // This is the behavior when it's active 
    case "stop" => 
     self become inactive 
    case "next" => 
     doSomethingWith(stream.getItem) 
     self ! "next" 
    } 

    def receive = inactive // Start out as inactive 
} 

Cheers,