attori Scala - peggiori pratiche?

Question

Mi sento un po 'insicuro su come utilizzare attori in Scala. Ho letto la documentazione su come fare le cose, ma credo che avrei anche bisogno di alcuni non lo fanno le regole per sentirsi liberi di usarli. Penso che ho paura che io li uso in un modo sbagliato, e non voglio nemmeno caso.

Si può pensare a qualcosa, che, se applicata, porterebbe a rompere i benefici che gli attori Scala portano, o anche i risultati errati?

Answer 1

• Evitare di !? , ove possibile. È ottenere un sistema bloccato!

• Sempre inviare un messaggio da un filo attore-sottosistema. Se questo significa la creazione di un attore transitoria tramite il metodo Actor.actor allora così sia:

  case ButtonClicked(src) => Actor.actor { controller ! SaveTrade(trdFld.text) }

• Aggiungere un "qualsiasi altro messaggio" gestore per le reazioni del vostro attore. Altrimenti è impossibile capire se si sta inviando un messaggio con l'attore sbagliato:

  case other => log.warning(this + " has received unexpected message " + other

• Non utilizzare Actor.actor per i vostri attori primari, sublcass Actor invece. La ragione di questo è che è solo da sottoclassi che è possibile fornire un metodo toString ragionevole. Anche in questo caso, il debug attori è molto difficile se il vostro log sono disseminati di affermazioni del tipo:

  12:03 [INFO] Sending RequestTrades(2009-10-12) to scala.actors.Actor$anonfun$1

• Documento gli attori di sistema, affermando esplicitamente che messaggi riceveranno e precisamente quanti dovrebbero calcolare la risposta. Utilizzando attori risultati nella conversione di una procedura standard (normalmente incapsulato all'interno di un metodo) per diventare diffusione logica attraverso reazioni dell'attore multipla. E 'facile perdersi senza una buona documentazione.

• Assicurarsi sempre è possibile comunicare con il vostro attore al di fuori del suo ciclo react per trovare il suo stato. Per esempio, ho sempre dichiarare un metodo da richiamare tramite un MBean che si presenta come il seguente frammento di codice. Può altrimenti essere molto difficile dire se il vostro attore è in esecuzione, si è spento, ha una grande coda di messaggi, ecc

.

def reportState = {
  val _this = this
  synchronized {
    val msg = "%s Received request to report state with %d items in mailbox".format(
                   _this, mailboxSize) 
    log.info(msg)
  }
  Actor.actor { _this ! ReportState }
}

• link ai tuoi attori insieme e usare trapExit = true -. Altrimenti può fallire in silenzio significa il programma non sta facendo quello che pensi che è e sarà probabilmente andare fuori della memoria come messaggi rimangono nella casella di posta dell'attore

• Credo che alcune altre scelte interessanti intorno firmate da decisioni da prendere con attori sono stati evidenziati qui e qui

Answer 2

So che questo in realtà non rispondere alla domanda, ma si dovrebbe almeno prendere il cuore nel fatto che la concorrenza basata su messaggi è molto meno incline a errori rispetto strano concorrenza a base di shared-memory-thread.

Presumo che avete visto le linee guida attore a Programmazione in Scala , ma per la cronaca:

• Gli attori non devono bloccare durante l'elaborazione di un messaggio. Dove si potrebbe desiderare di bloccare cercare di organizzare per ottenere un messaggio in seguito, invece.
• Usa react {} piuttosto che receive {} quando possibile.
• Comunicare con gli attori solo tramite messaggi.
• Preferisco messaggi immutabili.
• Fai messaggi autonomo.