Spring Framework Conexión de JVM entre sí

Question

Tengo 4 servidores y JVM está instalado en ellos. Escribí un servicio de Java que Quartz llama a este servicio cada 10 minutos. Pero en 4 servidores, cada 10 minutos se hacen 4 llamadas. Esta situación crea una condición de carrera. Solo quiero un servicio en 4 JVM.

¿Cómo se puede hacer eso con Spring Framework?

Answer 1

Esto es en realidad bastante fácil de configurar con cuarzo. Spring no puede ayudar mucho aquí ya que no tiene conocimiento de las otras JVM que se están ejecutando. Por otro lado, Quartz tiene el concepto de un programador agrupado.

Básicamente, debe configurar una sola base de datos que puedan compartir las 4 JVM. Esto se usará como un programador para las 4 instancias. Cuando se programa un trabajo, solo lo ejecuta una de las instancias que utilizan el programador en clúster.

Tomado de la wiki del sitio web de Quartz para clustering ( http://www.opensymphony.com/quartz/wikidocs/ConfigJDBCJobStoreClustering.html), esta es una configuración de ejemplo sobre cómo configurar el planificador en clúster. También puede establecer estas propiedades directamente desde la primavera si está configurando su programador de esa manera.

#============================================================================ 
# Configure Main Scheduler Properties 
#============================================================================ 

org.quartz.scheduler.instanceName = MyClusteredScheduler 
org.quartz.scheduler.instanceId = AUTO 

#============================================================================ 
# Configure ThreadPool 
#============================================================================ 

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool 
org.quartz.threadPool.threadCount = 25 
org.quartz.threadPool.threadPriority = 5 

#============================================================================ 
# Configure JobStore 
#============================================================================ 

org.quartz.jobStore.misfireThreshold = 60000 

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX 
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.oracle.OracleDelegate 
org.quartz.jobStore.useProperties = false 
org.quartz.jobStore.dataSource = myDS 
org.quartz.jobStore.tablePrefix = QRTZ_ 

org.quartz.jobStore.isClustered = true 
org.quartz.jobStore.clusterCheckinInterval = 20000 

#============================================================================ 
# Configure Datasources 
#============================================================================ 

org.quartz.dataSource.myDS.driver = oracle.jdbc.driver.OracleDriver 
org.quartz.dataSource.myDS.URL = jdbc:oracle:thin:@polarbear:1521:dev 
org.quartz.dataSource.myDS.user = quartz 
org.quartz.dataSource.myDS.password = quartz 
org.quartz.dataSource.myDS.maxConnections = 5 
org.quartz.dataSource.myDS.validationQuery=select 0 from dual 

Answer 2

Su pregunta no es muy clara, así que déjeme ver si lo entiendo: tiene 4 servidores, cada uno ejecutando Quartz dentro de una VM, y cada servidor tiene el mismo trabajo de cuarzo programado para ejecutarse cada 10 minutos, usando una expresión cron. Cada 10 minutos, los 4 servidores comienzan el mismo trabajo, creando su condición de carrera ya que todos intentan hacer lo mismo al mismo tiempo.

Esto no es realmente un trabajo para la primavera. Sin embargo, Quartz tiene capacidad de clúster, donde configura un trabajo para ejecutar solo un único servidor en el clúster. Utiliza una base de datos compartida para coordinar qué servidores ejecutan qué trabajo y se asegura de que no todos lo hagan juntos.

Los documentos tienen algo de información sobre este here, pero en el estilo habitual de opensymphony.com son bastante escasos e inútiles.

Answer 3

Lo que hago en nuestra aplicación web es para cada puesto de trabajo a ser envuelto en una clase que lleva a cabo un bloqueo global a través de su clúster (utilizo memcached, ya que no me importa si la tarea se ejecute con demasiada frecuencia), y solo ejecuta la tarea si obtuvo el bloqueo. A continuación, puede liberar el bloqueo cuando la tarea finalice (no olvide hacer esto en un finally).

Una ventaja de ajustar cada tarea en lugar de cambiar el programador es que puede tener algunos trabajos que se ejecutan en todas las máquinas, y algunos que solo se ejecutan en uno.