Chiamare un attore di blocco all'interno di un attore

Question

Dato invoco l'Actor dall'interno reagire fa questo blocco la Actor chiamando o è ancora elaborando altre richieste?

class worker extends Actor()
{
  def act() = {
    loop {
      react {
        msg =>
          var foo = another_actor !? 'bar' //Block here?
          println(foo)
      }
    }
}

Answer 1

questa domanda circa il fatto che attori non può elaborare i messaggi simulatneously (cioè ogni attore elabora sua casella di posta in sequenza).

Io di certo non credo che questo sia molto chiaro dalle spiegazioni in Programmazione in Scala . Si può (o quasi) ottenere quello che vuoi con la creazione di un attore on-the-fly:

loop {
   react {
      case Command(args) =>
         val f = other !! Request(args) //create a Future
         //now create inline actor
         val _this = self
         actor { //this creates an on-the-fly actor
           _this ! Result(args, f.get) //f.get is a blocking call              
         }
      case Result(args, result) =>
         //now process this 
   }
}

Naturalmente, il on-the-fly attore bloccare, ma non lasciare l'attore originale in grado di elaborare i nuovi messaggi. Il sottosistema attori creerà nuove discussioni fino a actors.maxPoolSize (di default è 256) se tutti gli attuali thread pool sono occupati.

Answer 2

!? sempre blocca il thread chiamante. se invocare in mezzo dell'attore reagire blocco, l'attore chiamata è bloccata pure.

L'idea principale di attori è un singolo thread di esecuzione . Un attore non procederà al messaggio successivo fino a quando quella attuale è terminata l'elaborazione. in questo modo, gli sviluppatori non hanno bisogno di preoccuparsi di concorrenza fino a quando i messaggi sono immuatable.