Cómo tener 2 JVMs hablando entre sí

Tengo la siguiente situación:

Tengo 2 procesos JVM (realmente 2 procesos java ejecutados por separado, no 2 subprocesos) ejecutándose en una máquina local. Llamémoslos ProcessA ProcessB .

Quiero que se comuniquen (intercambien datos) entre sí (por ejemplo, ProcessA envía un mensaje a ProcessB para hacer algo).

Ahora, soluciono este problema escribiendo un archivo temporal y este proceso explora periódicamente este archivo para obtener un mensaje. Creo que esta solución no es tan buena.

¿Cuál sería una mejor alternativa para lograr lo que quiero?

Múltiples opciones para IPC :

Redes basadas en Socket (Bare-Bones)

  • no necesariamente difícil , pero:
    • podría ser prolijo para poco,
    • podría ofrecer más superficie para los errores, a medida que escribe más código.
  • puede confiar en los marcos existentes, como Netty

RMI

  • Técnicamente, eso también es comunicación de red, pero eso es transparente para usted.

Completamente desarrollado paso de architectures

  • generalmente se basa en RMI o en comunicaciones de red, pero con soporte para conversaciones y flujos de trabajo complicados
  • podría ser demasiado pesado para algo simple
  • marcos como ActiveMQ o JBoss Messaging

Extensiones de administración Java (JMX)

  • más significado para la administración y el monitoreo de JVM , pero podría ayudar a implementar lo que desea si en su mayoría desea que un proceso busque otro para los datos, o envíele una solicitud de una acción, si no son demasiado complejos.
  • también funciona sobre RMI (entre otros protocolos posibles)
  • no es tan sencillo de entender al principio, pero en realidad es bastante simple de usar

Uso compartido de archivos / locking de archivos

  • eso es lo que estás haciendo en este momento
  • es factible, pero viene con muchos problemas para manejar

Señales

  • Simplemente puede enviar señales a su otro proyecto
  • Sin embargo, es bastante limitado y requiere que implemente una capa de traducción (sin embargo, es factible, pero es una idea bastante loca para jugar que nada serio.

Sin más detalles, un enfoque IPC basado en la red barebone parece ser el mejor, ya que es el:

  • más extensible (en términos de agregar nuevas funciones y flujos de trabajo a su
  • más liviano (en términos de espacio de memoria para su aplicación)
  • más simple (en términos de diseño)
  • más educativo (en términos de aprender cómo implementar IPC). (Como mencionó “socket es difícil” en un comentario, y realmente no es y debería ser algo en lo que trabaje)

Dicho esto, basado en su ejemplo (simplemente solicitando que el otro proceso realice una acción), JMX también podría ser lo suficientemente bueno para usted.

Agregué una biblioteca en github llamada Mappedbus ( http://github.com/caplogic/mappedbus ) que permite que dos (o muchos más) procesos Java / JVM se comuniquen mediante el intercambio de mensajes. La biblioteca utiliza un archivo mapeado de memoria y hace uso de lectura / escritura captar y agregar y volátil para sincronizar los diferentes lectores y escritores. He medido el rendimiento entre dos procesos usando esta biblioteca a 40 millones de mensajes / s con una latencia promedio de 25 ns para leer / escribir un solo mensaje.

Lo que estás buscando es inter-process communication . Java proporciona un marco IPC simple en forma de API Java RMI . Existen muchos otros mecanismos para la comunicación entre procesos, tales como tuberías, conectores, colas de mensajes (obviamente, todos estos son conceptos, por lo que existen marcos que los implementan).

Creo que en su caso Java RMI o una simple implementación de socket personalizado deberían ser suficientes.

Sockets con DataInput (Output) Stream, para enviar objetos Java de un lado a otro. Esto es más fácil que usar un archivo de disco, y mucho más fácil que Netty.

Tiendo a usar jGroup para formar clusters locales entre procesos. Funciona para nodos (también conocidos como procesos) en la misma máquina, dentro de la misma JVM o incluso a través de diferentes servidores.

Una vez que comprenda los conceptos básicos, es fácil trabajar con él y tener las opciones para ejecutar realmente dos o más procesos en la misma JVM hace que sea más fácil probar esos procesos fácilmente.

La sobrecarga y latencia es mínima si ambas están en la misma máquina (por lo general, solo una transferencia TCP de aproximadamente> 100 n por acción).

socket puede ser una mejor opción, creo.

    Intereting Posts