Scala acteurs – les pires pratiques?

Je ne suis pas certain de pouvoir utiliser des acteurs à Scala. J’ai lu de la documentation sur la façon de faire les choses, mais je suppose que j’aurais aussi besoin de certaines règles pour ne pas les utiliser. Je pense que je crains de ne pas les utiliser correctement et je ne le remarquerai même pas.

Pouvez-vous penser à quelque chose qui, s’il était appliqué, aboutirait à briser les avantages apportés par les acteurs Scala, voire des résultats erronés?

  • À éviter !? la mesure du possible. Vous aurez un système verrouillé!

  • Toujours envoyer un message à partir d’un thread de sous-système d’acteur. Si cela implique de créer un acteur transitoire via la méthode Actor.actor , il en va de même:

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

  • Ajoutez un gestionnaire “tout autre message” aux réactions de votre acteur. Sinon, il est impossible de savoir si vous envoyez un message au mauvais acteur:

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

  • N’utilisez pas Actor.actor pour vos acteurs principaux, remplacez plutôt Actor . La raison en est que c’est seulement en sous-classant que vous pouvez fournir une toSsortingng sensible à la toSsortingng . Encore une fois, le débogage des acteurs est très difficile si vos journaux sont remplis de déclarations telles que:

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

  • Documentez les acteurs de votre système, en indiquant explicitement les messages qu’ils recevront et comment ils devraient calculer la réponse. L’utilisation des acteurs se traduit par la conversion d’une procédure standard (normalement encapsulée dans une méthode) en une logique répartie sur les réactions de plusieurs acteurs. Il est facile de se perdre sans une bonne documentation.

  • Assurez-vous toujours de pouvoir communiquer avec votre acteur en dehors de sa boucle de react pour trouver son état. Par exemple, je déclare toujours une méthode à MBean via un MBean qui ressemble à l’extrait de code suivant. Il peut par ailleurs être très difficile de déterminer si votre acteur est en cours d’exécution, s’est éteint, a une grande file 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 } } 
  • trapExit = true vos acteurs ensemble et utilisez trapExit = true – sinon ils peuvent échouer en silence, ce qui signifie que votre programme ne fait pas ce que vous pensez être et va probablement perdre de la mémoire car les messages restnt dans la boîte aux lettres de l’acteur.

  • Je pense que d’autres choix intéressants concernant les décisions de conception à prendre en utilisant des acteurs ont été mis en évidence ici et ici

Je sais que cela ne répond pas vraiment à la question, mais vous devriez au moins prendre en compte le fait que la simultanéité basée sur les messages est beaucoup moins sujette à des erreurs bizarres que la simultanéité basée sur un thread de mémoire partagée.

Je présume que vous avez vu les directives des acteurs dans la programmation de Scala , mais pour le compte rendu:

  • Les acteurs ne doivent pas bloquer lors du traitement d’un message. Où vous voudrez peut-être bloquer, essayez plutôt de recevoir un message plus tard.
  • Utilisez react {} plutôt que de receive {} si possible.
  • Communiquer avec les acteurs uniquement via des messages.
  • Préférer les messages immuables.
  • Rendre les messages autonomes.