Quelles décisions de conception favoriseraient les acteurs de Scala au lieu de JMS?
Quelles sont les différences en utilisant Scala Actors au lieu de JMS?
Par exemple, du point de vue des performances et de l'évolutivité, qu'est-ce que le modèle Scala Actor ajoute par rapport à JMS? que JMS ne peut pas couvrir?
JMS et les acteurs Scala partagent une similitude théorique mais ne les considèrent pas comme résolvant nécessairement les mêmes problèmes sur le plan architectural. Les acteurs sont censés être une alternative légère à la concurrence en mémoire partagée où les races et les blocages sont JMS est une API sophistiquée destinée à couvrir la messagerie directe, la publication/l'abonnement, les transactions, l'intégration d'EJB, etc.
L'équivalent JMS le plus proche d'un acteur serait un bean géré par message soutenu par une file d'attente non persistante, non transactionnelle, non pub/sub. J'appellerai cela un "simple bean JMS".
Passons maintenant à vos questions.
Il est difficile de parler de performances, car JMS est une spécification plutôt qu'une implémentation. Néanmoins, lors de l'utilisation d'un bean JMS simple, je m'attendrais à des performances à peu près similaires avec peut-être un peu d'Edge à l'acteur en termes de temps et de mémoire. Lorsque vous ajoutez des fonctionnalités à JMS telles que pub/sub, transactions, etc., les performances vont naturellement se dégrader encore plus, mais vous essayez de comparer des pommes avec des oranges.
En ce qui concerne l'évolutivité, les beans JMS simples devraient évoluer à peu près exactement de la même manière que les acteurs. L'ajout de transactions dans le mix JMS nuira naturellement à l'évolutivité d'un montant dépendant de l'étendue des transactions.
La question plus large de ce que font les acteurs que JMS ne peut pas. Eh bien, sans sous-pub ou transactions intégrés, il semblerait que les acteurs soustraient JMS - et c'est globalement vrai. Mais voici le problème: les acteurs ont besoin de si peu de code que je peux les utiliser avec plaisir pour une concurrence très fine. En ordinaire Java code je pourrais dire "Je n'ai pas envie de baiser avec JMS et ses dépendances ou le code dont il a besoin etc. donc je vais juste générer un thread, utiliser un verrou et partager une structure de données. "Avec Scala acteurs, je suis beaucoup plus susceptible de dire" Je vais juste fouetter un acteur et passer à autre chose. "
Il y a aussi une différence philosophique dans la conception. Les acteurs ont un concept simple et intégré de hiérarchies de superviseurs. Les acteurs sont généralement utilisés dans une conception "laissez tomber". Si un acteur décède pour une raison quelconque, un autre acteur est responsable de décider quoi faire à ce sujet, comme redémarrer cet acteur, tuer un groupe d'acteurs et les redémarrer tous, ou tuer un groupe d'acteurs et lui-même afin qu'un autre acteur puisse traiter le problème. Ce genre de chose peut être ajouté à JMS, mais ce n'est pas au cœur de l'API et doit être géré de manière externe en quelque sorte.
Soit dit en passant, pour une bibliothèque d'acteurs Scala qui se déplace davantage dans les domaines couverts par JMS, voir Akka . Akka apporte également une approche déclarative de nombreuses stratégies de hiérarchie d'acteurs courantes.