Akka Acteur - attendre pendant un certain temps à attendre un message, envoyer un message

Est-il possible de faire une Actor attendre pour un montant de X secondes pour recevoir un message, et si un message est reçu, le traiter comme d'habitude, sinon envoyer un message à certains autres Actor (pré-déterminé dans le constructeur)?

OriginalL'auteur adelbertc | 2012-10-05

  1. 3

    Oui, si vous voulez attendre pour tout message, il vous suffit de définir un receiveTimeout: http://doc.akka.io/docs/akka/current/scala/actors.html#receive-timeout

    (La doc est un peu trompeur ici, vous pouvez définir la receiveTimeout après chaque message aussi)

    OriginalL'auteur Viktor Klang

  2. 17

    C'est possible, avoir un regard sur Akka Acteur "demander" et "Attendent" avec TimeoutException. Mais gardez à l'esprit que le blocage à l'intérieur d'un acteur est une très mauvaise idée car pendant ce temps, l'acteur ne peut pas gérer tous les autres messages. En outre, il bloque une Akka thread de traitement.

    Une meilleure approche est d'envoyer un message (feu et oublier) et planifier un événement de délai d'attente à l'aide de Akka planificateur. Lorsque la réponse arrive, d'annuler l'événement ou définir certains pavillon de sorte qu'il ne se déclenche pas si la réponse est réellement venu à temps.

    +1 pour le planificateur de la solution.

    OriginalL'auteur Tomasz Nurkiewicz

  3. 4

    Peut-être trop, mais vous pouvez consulter les Finite State Machine (FSM) trait.

    import akka._
import actor._
import util._
import duration._
import Impatient._

object Impatient {
  sealed trait State
  case object WaitingForMessage extends State
  case object MessageReceived extends State
  case object TimeoutExpired extends State

  sealed trait Data
  case object Unitialized extends Data

  //In
  case object Message
}

class Impatient(receiver: ActorRef) extends Actor with FSM[State, Data] {
  startWith(WaitingForMessage, Unitialized)

  when(WaitingForMessage, stateTimeout = 3 seconds) {
    case Event(StateTimeout, data) => goto(TimeoutExpired) using data //data is usually modified here
    case Event(Message, data) => goto(MessageReceived) using data //data is usually modified here
  }

  onTransition {
    case WaitingForMessage -> MessageReceived => stateData match {
      case data => log.info("Received message: " + data)
    }
    case WaitingForMessage -> TimeoutExpired => receiver ! TimeoutExpired
  }

  when(MessageReceived) {
    case _ => stay
  }

  when(TimeoutExpired) {
    case _ => stay
  }

  initialize
}

    Ici, il est en action:

    object Main extends App {
  import akka._
  import actor._
  import Impatient._

  val system = ActorSystem("System")

  val receiver = system.actorOf(Props(new Actor with ActorLogging {
    def receive = {
      case TimeoutExpired => log.warning("Timeout expired")
    }
  }))

  val impatient = system.actorOf(Props(new Impatient(receiver)), name = "Impatient")
  impatient ! Message

  val impatient2 = system.actorOf(Props(new Impatient(receiver)), name = "Impatient2")
  Thread.sleep(4000)
  impatient2 ! Message

  system.shutdown()
}

    OriginalL'auteur agilesteel