acteurs Scala - pires pratiques?

Question

Je me sens un peu d'insécurité sur l'utilisation des acteurs à Scala. J'ai lu la documentation sur la façon de faire des choses, mais je suppose que je devrais aussi besoin de NE PAS règles afin de se sentir libre de les utiliser. Je pense que je crains que je les utiliser d'une mauvaise façon, et je ne le remarquerez même pas.

Pouvez-vous penser à quelque chose, que, si elle est appliquée, aurait pour effet de briser les avantages que les acteurs Scala apportent, ou même les résultats erronés?

Answer 1

• Contournez !? lorsque cela est possible. Vous obtenir un système verrouillé!

• Toujours envoyer un message à partir d'un fil acteur-sous-système. Si cela signifie la création d'un acteur transitoire via la méthode Actor.actor alors soit:

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

• Ajouter un "tout autre message" gestionnaire aux réactions de votre acteur. Dans le cas contraire, il est impossible de savoir si vous envoyez un message au mauvais acteur:

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

• Ne pas utiliser Actor.actor pour vos principaux acteurs, sublcass Actor à la place. La raison en est qu'il est que par subclassing que vous pouvez fournir une méthode toString sensible. Encore une fois, le débogage des acteurs est très difficile si vos journaux sont jonchées des déclarations comme:

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

• Documenter les acteurs de votre système, indiquant explicitement quels sont les messages qu'ils recevront et avec précision comment ils doivent calculer la réponse. En utilisant les résultats des acteurs de la conversion d'une procédure standard (normalement encapsulé dans une méthode) pour devenir la propagation logique à travers les réactions des acteurs multiples. Il est facile de se perdre sans une bonne documentation.

• Assurez-vous toujours que vous pouvez communiquer avec votre acteur en dehors de sa boucle react pour trouver son état. Par exemple, je déclare toujours une méthode pour être invoquée par un MBean qui ressemble à l'extrait de code suivant. Il peut par ailleurs être très difficile de dire si votre acteur est en cours d'exécution, a fermé, a une grande file d'attente de messages, etc.

.

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 }
}

• Lien vos acteurs et utiliser trapExit = true -. Sinon ils peuvent échouer à-dire en silence votre programme ne fait pas ce que vous pensez qu'il est et sera probablement sortir de la mémoire sous forme de messages restent dans la boîte aux lettres de l'acteur

• Je pense que d'autres choix intéressants autour de décisions concernant la conception à faire appel à des acteurs ont été mis en évidence ici et ici

Answer 2

Je sais que cela ne répond pas vraiment à la question, mais vous devriez au moins prendre le coeur dans le fait que la concurrence basée sur des messages est beaucoup moins sujette aux erreurs que Weird mémoire à base concurrency-fil partagé.

Je suppose que vous avez vu les lignes directrices de l'acteur dans Programmation à Scala , mais pour l'enregistrement:

• Les acteurs ne devraient pas bloquer lors du traitement d'un message. Où vous pouvez bloquer essayer d'arranger pour obtenir un message plus tard à la place.
• Utilisez react {} plutôt que receive {} si possible.
• Communiquer avec les acteurs que par les messages.
• Préférez les messages immuables.
• messages autonome.