quartz集群分布式(并发)部署解决方案-Spring

项目中使用分布式并发部署定时任务，多台跨JVM，按照常理逻辑每个JVM的定时任务会各自运行，这样就会存在问题，多台分布式JVM机器的应用服务同时干活，一个是加重服务负担，另外一个是存在严重的逻辑问题，比如需要回滚的数据，就回滚了多次，刚好quartz提供很好的解决方案。

集群分布式并发环境中使用QUARTZ定时任务调度，会在各个节点会上报任务，存到数据库中，执行时会从数据库中取出触发器来执行，如果触发器的名称和执行时间相同，则只有一个节点去执行此任务。

如果此节点执行失败，则此任务则会被分派到另一节点执行，中途也会自动检查失效的定时调度，发现不成功的，其他节点立马接过来继续完成定时任务。对应的定时任务调度表比较多，有11个。

此方法是结合Spring与quartz，实际解决方案如下：

####applicationContext-scheduler.xml### spring 3.11

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"

  xmlns:task="http://www.springframework.org/schema/task"

  xsi:schemaLocation="http://www.springframework.org/schema/beans

            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

            http://www.springframework.org/schema/context

            http://www.springframework.org/schema/context/spring-context-3.2.xsd

            http://www.springframework.org/schema/task

            http://www.springframework.org/schema/task/spring-task-3.2.xsd">

  <context:annotation-config />

  <context:component-scan base-package="com.dennis.walking.api.web.schedule" />

  <bean id="rollbackOrderStatus" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">

    <property name="jobClass" value="com.dennis.walking.api.web.schedule.ReleaseQtyAndUpdateOrderStatusSchedule" />

    <property name="durability" value="true" />

  </bean>

  <bean id="rollbackOrderStatusTrigger" class="com.dennis.walking.api.web.schedule.PersistableCronTriggerFactoryBean">

    <property name="jobDetail" ref="rollbackOrderStatus" />

    <property name="cronExpression">

      <value>0 0/5 * * * ?</value>

    </property>

    <property name="timeZone">

      <value>GMT+8:00</value>

    </property>

  </bean>

  <bean id="quartzScheduler" parent="baseQuartzScheduler">

    <property name="configLocation" value="classpath:quartz.properties" />

    <property name="autoStartup" value="true" />

    <!-- This name is persisted as SCHED_NAME in db. for local testing could change to unique name to avoid collision with dev server -->

    <property name="schedulerName" value="apiQuartzScheduler" />

    <!-- NOTE: Must add both the jobDetail and trigger to the scheduler! -->

    <property name="triggers">

      <list>

        <ref bean="rollbackOrderStatusTrigger" />

      </list>

    </property>

    <property name="jobDetails">

      <list>

        <ref bean="rollbackOrderStatus" />

      </list>

    </property>

  </bean>

  <bean id="baseQuartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

    <!--

    <property name="configLocation" value="classpath:quartz.properties" />

     -->

    <property name="dataSource" ref="dataSource" />

    <property name="transactionManager" ref="transManager" />

    <!-- This name is persisted as SCHED_NAME in db. for local testing could change to unique name to avoid collision with dev server -->

    <property name="schedulerName" value="quartzScheduler" />

    <!-- Will update database cron triggers to what is in this jobs file on each deploy. Replaces all previous trigger and job data that was in the database. YMMV -->

    <property name="overwriteExistingJobs" value="true" />

    <!--

    <property name="autoStartup" value="true" />

     -->

    <property name="applicationContextSchedulerContextKey" value="applicationContext" />

    <property name="jobFactory">

      <bean class="com.dennis.walking.api.web.schedule.AutowiringSpringBeanJobFactory" />

    </property>

    <!-- NOTE: Must add both the jobDetail and trigger to the scheduler! -->

    <!--

    <property name="jobDetails">

      <list>

      </list>

    </property>

    <property name="triggers">

      <list>

      </list>

    </property>

    -->

  </bean>

</beans>

记得对应下面的三个类文件。

###quartz.properties###

# Using Spring datasource in quartzJobsConfig.xml

# Spring uses LocalDataSourceJobStore extension of JobStoreCMT

org.quartz.jobStore.useProperties=true

org.quartz.jobStore.tablePrefix=QRTZ_

org.quartz.jobStore.isClustered=true

# 10 mins

org.quartz.jobStore.clusterCheckinInterval=600000

org.quartz.scheduler.skipUpdateCheck=true

# Change this to match your DB vendor

org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate

# Needed to manage cluster instances

org.quartz.scheduler.instanceId=AUTO

org.quartz.scheduler.instanceName=MY_JOB_SCHEDULER

org.quartz.scheduler.rmi.export=false

org.quartz.scheduler.rmi.proxy=false

org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool

org.quartz.threadPool.threadCount=10

org.quartz.threadPool.threadPriority=5

org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true

# Configure Plugins

org.quartz.plugin.triggHistory.class = \

  org.quartz.plugins.history.LoggingTriggerHistoryPlugin

org.quartz.plugin.triggHistory.triggerFiredMessage = \

  Trigger \{1\}.\{0\} fired job \{6\}.\{5\} at: \{4, date, HH:mm:ss MM/dd/yyyy}

org.quartz.plugin.triggHistory.triggerCompleteMessage = \

  Trigger \{1\}.\{0\} completed firing job \{6\}.\{5\} at \{4, date, HH:mm:ss MM/dd/yyyy\}.

quartz定时调度常用时间点设置

"0 0 12 * * ?"                     Fire at 12pm (noon) every day

"0 15 10 ? * *"                   Fire at 10:15am every day

"0 15 10 * * ?"                   Fire at 10:15am every day

"0 15 10 * * ? *"                 Fire at 10:15am every day

"0 15 10 * * ? 2005"           Fire at 10:15am every day during the year 2005

"0 * 14 * * ?"                     Fire every minute starting at 2pm and ending at 2:59pm, every day

"0 0/5 14 * * ?"                  Fire every 5 minutes starting at 2pm and ending at 2:55pm, every day

"0 0/5 14,18 * * ?"              Fire every 5 minutes starting at 2pm and ending at 2:55pm, AND fire every 5 minutes starting at 6pm and ending at 6:55pm, every day

"0 0-5 14 * * ?"                   Fire every minute starting at 2pm and ending at 2:05pm, every day

"0 10,44 14 ? 3 WED"         Fire at 2:10pm and at 2:44pm every Wednesday in the month of March.

"0 15 10 ? * MON-FRI"        Fire at 10:15am every Monday, Tuesday, Wednesday, Thursday and Friday

"0 15 10 15 * ?"                  Fire at 10:15am on the 15th day of every month

"0 15 10 L * ?"                    Fire at 10:15am on the last day of every month

"0 15 10 ? * 6L"                   Fire at 10:15am on the last Friday of every month

"0 15 10 ? * 6L"                   Fire at 10:15am on the last Friday of every month

"0 15 10 ? * 6L 2002-2005"   Fire at 10:15am on every last Friday of every month during the years 2002, 2003, 2004 and 2005

"0 15 10 ? * 6#3"                 Fire at 10:15am on the third Friday of every month

真实运行的业务类：ReleaseQtyAndUpdateOrderStatusSchedule.java

应为要持久化等特性操作,需要继承 QuartzJobBean

由于要被持久化,所以不能存放xxxxManager类似对象,

只能从每次从QuartzJobBean注入的ApplicationContext 中去取出

继承QuartzJobBean，实现方法executeInternal

package com.dennis.walking.api.web.schedule;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.scheduling.quartz.QuartzJobBean;

import org.springframework.stereotype.Component;

import com.dennis.walking.api.service.OrderService;

@Component

public class ReleaseQtyAndUpdateOrderStatusSchedule extends QuartzJobBean {

  private Log log = LogFactory.getLog(this.getClass());

  @Autowired

  OrderService orderService;

  protected void executeInternal(JobExecutionContext arg0)

      throws JobExecutionException {

    log.info("dennis test execute schedule start ");

    try {

      orderService.releaseQtyAndUpdateOrderStatus();

    } catch (Exception e) {

      e.printStackTrace();

      log.error("execute ReleaseQtyAndUpdateOrderStatus schedule error:"

          + e.getMessage());

    }

    log.info("dennis test exxcute schedule end");

  }

}

持久化数据：PersistableCronTriggerFactoryBean.java 保存数据到数据库中

package com.dennis.walking.api.web.schedule;

import org.springframework.scheduling.quartz.CronTriggerFactoryBean;

import org.springframework.scheduling.quartz.JobDetailAwareTrigger;

/**

 * Needed to set Quartz useProperties=true when using Spring classes, because

 * Spring sets an object reference on JobDataMap that is not a String

 *

 * @see http://site.trimplement.com/using-spring-and-quartz-with-jobstore-properties

 *      /

 * @see http

 *      ://forum.springsource.org/showthread.php?130984-Quartz-error-IOException

 */

public class PersistableCronTriggerFactoryBean extends CronTriggerFactoryBean {

  @Override

  public void afterPropertiesSet() {

    super.afterPropertiesSet();

    System.out.println("PersistableCronTriggerFactoryBean-------------------");

    // Remove the JobDetail element

    getJobDataMap().remove(JobDetailAwareTrigger.JOB_DETAIL_KEY);

  }

}

###AutowiringSpringBeanJobFactory.java### 使用spring的 bean文件时，需要使用此类

package com.dennis.walking.api.web.schedule;

import org.quartz.spi.TriggerFiredBundle;

import org.springframework.beans.factory.config.AutowireCapableBeanFactory;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.scheduling.quartz.SpringBeanJobFactory;

/**

 * Autowire Quartz Jobs with Spring context dependencies

 *

 * @see http

 *      ://stackoverflow.com/questions/6990767/inject-bean-reference-into-a-quartz

 *      -job-in-spring/15211030#15211030

 */

public final class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory

    implements ApplicationContextAware {

  private transient AutowireCapableBeanFactory beanFactory;

  public void setApplicationContext(final ApplicationContext context) {

    beanFactory = context.getAutowireCapableBeanFactory();

  }

  @Override

  protected Object createJobInstance(final TriggerFiredBundle bundle)

      throws Exception {

    final Object job = super.createJobInstance(bundle);

    beanFactory.autowireBean(job);

    System.out.println("AutowiringSpringBeanJobFactory-------------------");

    return job;

  }

}

###tables_mysql.sql### 需要建立的11张表

#

# Quartz seems to work best with the driver mysql-connector-java-5.1.34-bin.jar

#

# PLEASE consider using mysql with innodb tables to avoid locking issues

#

# In your Quartz properties file, you'll need to set

# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate

#

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;

DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;

DROP TABLE IF EXISTS QRTZ_LOCKS;

DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_TRIGGERS;

DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;

DROP TABLE IF EXISTS QRTZ_CALENDARS;

CREATE TABLE QRTZ_JOB_DETAILS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    JOB_NAME  VARCHAR(200) NOT NULL,

    JOB_GROUP VARCHAR(200) NOT NULL,

    DESCRIPTION VARCHAR(250) NULL,

    JOB_CLASS_NAME   VARCHAR(250) NOT NULL,

    IS_DURABLE VARCHAR(1) NOT NULL,

    IS_NONCONCURRENT VARCHAR(1) NOT NULL,

    IS_UPDATE_DATA VARCHAR(1) NOT NULL,

    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,

    JOB_DATA BLOB NULL,

    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)

);

CREATE TABLE QRTZ_TRIGGERS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    TRIGGER_NAME VARCHAR(200) NOT NULL,

    TRIGGER_GROUP VARCHAR(200) NOT NULL,

    JOB_NAME  VARCHAR(200) NOT NULL,

    JOB_GROUP VARCHAR(200) NOT NULL,

    DESCRIPTION VARCHAR(250) NULL,

    NEXT_FIRE_TIME BIGINT(13) NULL,

    PREV_FIRE_TIME BIGINT(13) NULL,

    PRIORITY INTEGER NULL,

    TRIGGER_STATE VARCHAR(16) NOT NULL,

    TRIGGER_TYPE VARCHAR(8) NOT NULL,

    START_TIME BIGINT(13) NOT NULL,

    END_TIME BIGINT(13) NULL,

    CALENDAR_NAME VARCHAR(200) NULL,

    MISFIRE_INSTR SMALLINT(2) NULL,

    JOB_DATA BLOB NULL,

    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)

        REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)

);

CREATE TABLE QRTZ_SIMPLE_TRIGGERS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    TRIGGER_NAME VARCHAR(200) NOT NULL,

    TRIGGER_GROUP VARCHAR(200) NOT NULL,

    REPEAT_COUNT BIGINT(7) NOT NULL,

    REPEAT_INTERVAL BIGINT(12) NOT NULL,

    TIMES_TRIGGERED BIGINT(10) NOT NULL,

    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

);

CREATE TABLE QRTZ_CRON_TRIGGERS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    TRIGGER_NAME VARCHAR(200) NOT NULL,

    TRIGGER_GROUP VARCHAR(200) NOT NULL,

    CRON_EXPRESSION VARCHAR(200) NOT NULL,

    TIME_ZONE_ID VARCHAR(80),

    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

);

CREATE TABLE QRTZ_SIMPROP_TRIGGERS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    TRIGGER_NAME VARCHAR(200) NOT NULL,

    TRIGGER_GROUP VARCHAR(200) NOT NULL,

    STR_PROP_1 VARCHAR(512) NULL,

    STR_PROP_2 VARCHAR(512) NULL,

    STR_PROP_3 VARCHAR(512) NULL,

    INT_PROP_1 INT NULL,

    INT_PROP_2 INT NULL,

    LONG_PROP_1 BIGINT NULL,

    LONG_PROP_2 BIGINT NULL,

    DEC_PROP_1 NUMERIC(13,4) NULL,

    DEC_PROP_2 NUMERIC(13,4) NULL,

    BOOL_PROP_1 VARCHAR(1) NULL,

    BOOL_PROP_2 VARCHAR(1) NULL,

    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

);

CREATE TABLE QRTZ_BLOB_TRIGGERS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    TRIGGER_NAME VARCHAR(200) NOT NULL,

    TRIGGER_GROUP VARCHAR(200) NOT NULL,

    BLOB_DATA BLOB NULL,

    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),

    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)

);

CREATE TABLE QRTZ_CALENDARS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    CALENDAR_NAME  VARCHAR(200) NOT NULL,

    CALENDAR BLOB NOT NULL,

    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)

);

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    TRIGGER_GROUP  VARCHAR(200) NOT NULL,

    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)

);

CREATE TABLE QRTZ_FIRED_TRIGGERS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    ENTRY_ID VARCHAR(95) NOT NULL,

    TRIGGER_NAME VARCHAR(200) NOT NULL,

    TRIGGER_GROUP VARCHAR(200) NOT NULL,

    INSTANCE_NAME VARCHAR(200) NOT NULL,

    FIRED_TIME BIGINT(13) NOT NULL,

    SCHED_TIME BIGINT(13) NOT NULL,

    PRIORITY INTEGER NOT NULL,

    STATE VARCHAR(16) NOT NULL,

    JOB_NAME VARCHAR(200) NULL,

    JOB_GROUP VARCHAR(200) NULL,

    IS_NONCONCURRENT VARCHAR(1) NULL,

    REQUESTS_RECOVERY VARCHAR(1) NULL,

    PRIMARY KEY (SCHED_NAME,ENTRY_ID)

);

CREATE TABLE QRTZ_SCHEDULER_STATE

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    INSTANCE_NAME VARCHAR(200) NOT NULL,

    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,

    CHECKIN_INTERVAL BIGINT(13) NOT NULL,

    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)

);

CREATE TABLE QRTZ_LOCKS

  (

    SCHED_NAME VARCHAR(120) NOT NULL,

    LOCK_NAME  VARCHAR(40) NOT NULL,

    PRIMARY KEY (SCHED_NAME,LOCK_NAME)

);

commit;

###如果定时任务比较多，建议增加索引提升速度。

/*

reate index idx_qrtz_j_req_recovery on qrtz_job_details(SCHED_NAME,REQUESTS_RECOVERY);

create index idx_qrtz_j_grp on qrtz_job_details(SCHED_NAME,JOB_GROUP);

create index idx_qrtz_t_j on qrtz_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);

create index idx_qrtz_t_jg on qrtz_triggers(SCHED_NAME,JOB_GROUP);

create index idx_qrtz_t_c on qrtz_triggers(SCHED_NAME,CALENDAR_NAME);

create index idx_qrtz_t_g on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP);

create index idx_qrtz_t_state on qrtz_triggers(SCHED_NAME,TRIGGER_STATE);

create index idx_qrtz_t_n_state on qrtz_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);

create index idx_qrtz_t_n_g_state on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);

create index idx_qrtz_t_next_fire_time on qrtz_triggers(SCHED_NAME,NEXT_FIRE_TIME);

create index idx_qrtz_t_nft_st on qrtz_triggers(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);

create index idx_qrtz_t_nft_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);

create index idx_qrtz_t_nft_st_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);

create index idx_qrtz_t_nft_st_misfire_grp on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

create index idx_qrtz_ft_trig_inst_name on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME);

create index idx_qrtz_ft_inst_job_req_rcvry on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);

create index idx_qrtz_ft_j_g on qrtz_fired_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);

create index idx_qrtz_ft_jg on qrtz_fired_triggers(SCHED_NAME,JOB_GROUP);

create index idx_qrtz_ft_t_g on qrtz_fired_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);

create index idx_qrtz_ft_tg on qrtz_fired_triggers(SCHED_NAME,TRIGGER_GROUP);

*/

本文测试软件环境使用的jar版本是：

quartz-2.2.1.jar mysql-connector-java-5.1.34.jar

linux apache-tomcat-7.0.47 ava version "1.7.0_72" 64位

windows7 java version "1.7.0_45" 64位 jetty

Quartz是一个开放源码项目，专注于任务调度器，提供了极为广泛的特性如持久化任务，集群和分布式任务等。 Quartz核心是调度器，还采用多线程管理。

1.持久化任务：当应用程序停止运行时，所有调度信息不被丢失，当你重新启动时，调度信息还存在，这就是持久化任务（保存到数据库表中）。

2.集群和分布式处理：当在集群环境下，当有配置Quartz的多个客户端时（节点），采用Quartz的集群和分布式处理时，我们要了解几点好处

1) 一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。

2） Quartz调度是通过触发器的类别来识别不同的任务，在不同的节点定义相同的触发器的类别，这样在集群下能稳定的运行，一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。

3）分布式体现在当相同的任务定时在一个时间点，在那个时间点，不会被两个节点同时执行。

Quartz的 Task（11 张表）实例化采用数据库存储，基于数据库引擎及 High-Available 的策略（集群的一种策略）自动协调每个节点的 Quartz。

quartz集群分布式(并发)部署解决方案-Spring的更多相关文章

quartz集群分布式(并发)部署解决方案
项目中使用分布式并发部署定时任务,多台跨JVM,按照常理逻辑每个JVM的定时任务会各自运行,这样就会存在问题,多台分布式JVM机器的应用服务同时干活,一个是加重服务负担,另外一个是存在严重的逻辑问题, ...
Spring+Quartz集群环境下定时调度的解决方案
集群环境可能出现的问题在上一篇博客我们介绍了如何在自己的项目中从无到有的添加了Quartz定时调度引擎,其实就是一个Quartz 和Spring的整合过程,很容易实现,但是我们现在企业中项目通常都是 ...
Spring+quartz集群解决多服务器部署定时器重复执行的问题
一.问题描述 Spring自带的Task虽然能很好使用定时任务,只需要做些简单的配置就可以了.不过如果部署在多台服务器上的时候,这样定时任务会在每台服务器都会执行,造成重复执行. 二.解决方案 Spr ...
教你如何利用分布式的思想处理集群的参数配置信息——spring的configurer妙用
引言最近LZ的技术博文数量直线下降,实在是非常抱歉,之前LZ曾信誓旦旦的说一定要把<深入理解计算机系统>写完,现在看来,LZ似乎是在打自己脸了.尽管LZ内心一直没放弃,但从现状来看,需要 ...
Spring+quartz集群配置，Spring定时任务集群，quartz定时任务集群
Spring+quartz集群配置,Spring定时任务集群,quartz定时任务集群 >>>>>>>>>>>>>> ...
集群环境下定时调度的解决方案之Quartz集群
集群环境可能出现的问题在上一篇博客我们介绍了如何在自己的项目中从无到有的添加了Quartz定时调度引擎,其实就是一个Quartz 和Spring的整合过程,很容易实现,但是我们现在企业中项目通常都是 ...
Spring+Quartz 集群
这几天给Spring+Quartz的集群折腾得死去活来,google了无数页总算搞定,记下一些要点备以后使用. 单独的Quartz集群在http://unmi.blogjava.net/有Unmi翻译 ...
(4) Spring中定时任务Quartz集群配置学习
原来配置的Quartz是通过spring配置文件生效的,发现在非集群式的服务器上运行良好,但是将工程部署到水平集群服务器上去后改定时功能不能正常运行,没有任何错误日志,于是从jar包.JDK版本. ...
Elastic Stack之ElasticSearch分布式集群二进制方式部署
Elastic Stack之ElasticSearch分布式集群二进制方式部署作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 想必大家都知道ELK其实就是Elasticsearc ...

随机推荐

C++_系列自学课程_第_7_课_数组_《C++ Primer 第四版》
说到数组,大家应该都很熟悉,在C.Pascal.Java等语言中,都有数组的概念.在C++中也提供了对数组的支持.数组简单来说就是一堆相同数据类型对象的集合. 这里要把握住两个要点: 相同的数据类型 ...
【面试大系】PHP程序员的知识盘点
总结下,PHP面试中常见的知识点,以备查漏补缺和不时之用. 1)php面试题之一——PHP核心技术(高级部分)
CentOS操作记录
基本操作记录 1.centos已经进到图形界面后怎么打开命令行:ctrl+alt+F3 得到如下命令界面用用户名和密码登录切换回图形界面时输入的命令:ctrl+alt+F1 2.重新启动系统:#r ...
20、ASP.NET MVC入门到精通——WebAPI
本系列目录:ASP.NET MVC4入门到精通系列目录汇总微软有了Webservice和WCF,为什么还要有WebAPI? 用过WCF的人应该都清楚,面对那一大堆复杂的配置文件,有时候一出问题,真的 ...
jquery限制文本框只能输入金额
$("#batch_diff_percent").keyup(function () { var reg = $(this).val().match(/\d+\.?\d{0,2}/ ...
从CSS实现正片叠底看=>混合模式mix-blend-mode
兼容性:这个东西说多了也没意思,像HTML5和CSS3这种兼容性时刻变化的东东,我们最好在自己支持的设备上实验,不支持,就在想办法呗,这个东西就是为了方便和好玩所有属性: mix-blend-mod ...
UIPickerView的使用(三)
前两篇文章 UIPickerView的使用(一) . UIPickerView的使用(二),学习了UIPickerView的单列选择器和双列选择器的使用. 现在我们一起学习相互依赖的多列选择器 1.遵 ...
Objective-C 快速入门--基础(三)
1.OC有几种方式创建字符串对象?如:如何创建一个字符串对象:@“Baby”. OC中有3种方式创建字符串对象: 示例:main.m文件中: 控制台输出: 2.OC中如何获取字符串的长度? OC中获取 ...
Android 学习心得快速排序
快速排序(Quicksort) 是对冒泡排序的一种改进,它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分 ...
Genymotion 解决虚拟镜像下载速度特别慢的问题
Genymotion号称Android模拟器中运行最快的,但是服务器在国外,Android镜像下载起来那个速度就不想说了. Add new device后下载速度太慢了,容易失败解决方法如下: ...

quartz集群分布式(并发)部署解决方案-Spring

quartz集群分布式(并发)部署解决方案-Spring的更多相关文章

随机推荐

热门专题