java - ¿Qué decisiones de diseño favorecerían a los actores de Scala en lugar de a JMS?
(1)
Los actores de JMS y Scala comparten una similitud teórica, pero no piensan que necesariamente resuelvan los mismos problemas desde el punto de vista arquitectónico. Los actores están destinados a ser una alternativa ligera a la concurrencia de memoria compartida donde las carreras y los bloqueos son generalmente más difíciles de crear accidentalmente. JMS es una API sofisticada que abarca mensajes directos, publicaciones / suscripciones, transacciones, integración EJB, etc.
El JMS más cercano equivalente a un actor sería un bean controlado por mensajes que está respaldado por una cola no persistente, no transaccional, no pública / secundaria. Llamaré a eso un "frijol JMS simple".
Ahora, a tus preguntas.
El rendimiento es algo difícil de hablar ya que JMS es una especificación en lugar de una implementación. Sin embargo, cuando se usa un frijol JMS simple, esperaría que el rendimiento fuera más o menos similar, quizás con una ventaja para el actor en tiempo y memoria. A medida que agrega capacidades a JMS, como pub / sub, transacciones, etc. el rendimiento se degradará naturalmente aún más, pero luego está tratando de comparar las manzanas con las naranjas.
En cuanto a la escalabilidad, los beans JMS simples deberían escalar casi exactamente de la misma manera que los actores. Agregar transacciones en la mezcla JMS afectará naturalmente la escalabilidad en una cantidad que depende del alcance de las transacciones.
La pregunta más amplia de qué hacen los actores que JMS no puede. Bueno, sin sub o transacciones de pub incorporadas parecería que los actores restan de JMS, y en términos generales eso es cierto. Pero aquí está la cosa: los actores requieren tan poco código que pueda usarlos alegremente para una concurrencia de grano muy fino. En el código Java normal podría decir: "No tengo ganas de joder con JMS y sus dependencias o el código que requiere, etc. por lo que voy a generar un hilo, usar un bloqueo y compartir una estructura de datos". Con los actores de Scala, es mucho más probable que diga "Voy a azotar a un actor y seguir adelante".
También hay una diferencia filosófica en el diseño. Los actores tienen un concepto simple y construido de jerarquías de supervisor. Los actores se usan generalmente en un diseño de "deja que se cuelgue". Si un actor muere por algún motivo, entonces otro actor es responsable de decidir qué hacer al respecto, como reiniciar ese actor, matar a un grupo de actores y reiniciarlos a todos, o matar a un grupo de actores y a sí mismo para que otro actor pueda lidiar con el problema. Ese tipo de cosas se puede agregar a JMS, pero no es esencial para la API y debe gestionarse externamente de alguna manera.
Por cierto, para una biblioteca de actores de Scala que se mueve más en los reinos que cubre JMS, ve a Akka . Akka también aporta un enfoque declarativo a muchas estrategias comunes de jerarquía de actores.
¿Cuáles son las diferencias con Scala Actors en lugar de JMS?
Por ejemplo, desde una perspectiva de rendimiento y escalabilidad, ¿qué añade el modelo Scala Actor en comparación con JMS? ¿En qué casos tiene más sentido utilizar actores en lugar de JMS, es decir, qué problemas abordan los actores que JMS no puede cubrir?