Spring Framework Connessione JVM tra loro

Question

Ho 4 server e JVM è installato su di essi. Ho scritto un servizio java che Quartz chiama questo servizio ogni 10 minuti. Ma in 4 server, ogni 10 minuti vengono effettuate 4 chiamate. Questa sitiuation crea condizioni di competizione. Voglio un solo servizio su 4 JVM.

Come posso farlo con Spring Framework?

Answer 1

Questo è in realtà piuttosto facile da configurare con Quartz. La stessa primavera non può aiutarti molto poiché non è a conoscenza delle altre JVM in esecuzione. Il quarzo d'altra parte ha il concetto di uno schedulatore in cluster.

Fondamentalmente è necessario impostare un singolo database che tutte le 4 JVM possano condividere. Questo sarà usato come schedulatore per tutte e 4 le istanze. Quando un lavoro è pianificato, viene eseguito da una sola istanza utilizzando lo scheduler in cluster.

Tratto dal wiki del sito Web Quartz per il clustering ( http://www.opensymphony.com/quartz/wikidocs/ConfigJDBCJobStoreClustering.html), questo è un esempio di configurazione su come impostare lo scheduler in cluster. È anche possibile impostare queste proprietà direttamente da primavera se si sta configurando il pianificatore in quel modo.

#============================================================================ 
# 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

La tua domanda non è molto chiara, quindi vediamo se sto capendo: hai 4 server, ognuno con Quartz in esecuzione all'interno di una VM, e ogni server ha lo stesso processo al quarzo pianificato per essere eseguito ogni 10 minuti, usando un'espressione cron. Ogni 10 minuti, tutti e 4 i server danno il via allo stesso lavoro, creando le tue condizioni di gara mentre tutti cercano di fare la stessa cosa allo stesso tempo.

Questo non è proprio un lavoro per la primavera. Tuttavia, Quartz ha capacità di clustering, in cui si configura un lavoro per eseguire solo un singolo server nel cluster. Utilizza un database condiviso per coordinare i server che eseguono il lavoro e si assicura che non tutti lo facciano insieme.

I documenti hanno alcune informazioni su questo here, ma nel solito stile opensymphony.com sono piuttosto scarse e inutili.

Answer 3

Quello che faccio nella nostra applicazione web è per ogni lavoro ad essere avvolto in una classe che tira fuori un blocco globale attraverso il cluster (io uso memcached, come non mi interessa se l'operazione viene eseguita troppo spesso) e esegue l'attività solo se ha ottenuto il blocco. Può quindi rilasciare il blocco al termine dell'attività (non dimenticare di farlo in un finally).

Uno dei vantaggi del wrapping di ogni lavoro piuttosto che la modifica dello scheduler è che è possibile avere alcuni processi che girano su tutte le macchine e alcuni che vengono eseguiti solo su uno.