zookeeper实现分布式quartz调度

最新推荐文章于 2024-08-08 14:33:50 发布
最新推荐文章于 2024-08-08 14:33:50 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： 杂

目的
利用zookeeper的特性，来控制quartz实现分布式调度，保证quartz的单点运行，同时解除quartz自身分布式部署对数据库的依赖，保证同一时刻只有一个quartz应用在执行任务。

实现方式
利用zk的分布式独占锁，控制quartz应用执行节点，让拿到独占锁的quartz应用执行调度，没有拿到独占锁的quartz处理等待状态。

类图

核心代码

Java代码 收藏代码
public class TriggerBean {

/** 
 * 标识 
 */  
private String key;  
/** 
 * 所属组 
 */  
private String group;  
/** 
 * 描述 
 */  
private String description;  
/** 
 * 启动时间 
 */  
private String startTime;  
/** 
 * 结束时间 
 */  
private String endTime;  
/** 
 * 优先级 
 */  
private Integer priority;  
/** 
 * 日历名称 
 */  
private String calendarName;  
/** 
 * 失火指令（参数0,1,2） 
 * MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY = -1 
 * MISFIRE_INSTRUCTION_SMART_POLICY = 0 (默认) 
 * MISFIRE_INSTRUCTION_FIRE_ONCE_NOW = 1 
 * MISFIRE_INSTRUCTION_DO_NOTHING = 2 
 */  
private Integer misfireInstruction;  
/** 
 * 任务代理类 
 */  
private JobDetailProxyBean jobDetail;  

public String getKey() {  
    return key;  
}  

public void setKey(String key) {  
    this.key = key;  
}  

public String getGroup() {  
    return group;  
}  

public void setGroup(String group) {  
    this.group = group;  
}  

public String getDescription() {  
    return description;  
}  

public void setDescription(String description) {  
    this.description = description;  
}  

public String getStartTime() {  
    return startTime;  
}  

public void setStartTime(String startTime) {  
    this.startTime = startTime;  
}  

public String getEndTime() {  
    return endTime;  
}  

public void setEndTime(String endTime) {  
    this.endTime = endTime;  
}  

public Integer getPriority() {  
    return priority;  
}  

public void setPriority(Integer priority) {  
    this.priority = priority;  
}  

public String getCalendarName() {  
    return calendarName;  
}  

public void setCalendarName(String calendarName) {  
    this.calendarName = calendarName;  
}  

public Integer getMisfireInstruction() {  
    return misfireInstruction;  
}  

public void setMisfireInstruction(Integer misfireInstruction) {  
    this.misfireInstruction = misfireInstruction;  
}  

public JobDetailProxyBean getJobDetail() {  
    return jobDetail;  
}  

public void setJobDetail(JobDetailProxyBean jobDetail) {  
    this.jobDetail = jobDetail;  
}

}
Java代码 收藏代码
public class CronTriggerBean extends TriggerBean {

/** 
 * CRON表达式 
 */  
private String cronExpression;  

public String getCronExpression() {  
    return cronExpression;  
}  

public void setCronExpression(String cronExpression) {  
    this.cronExpression = cronExpression;  
}

}

Java代码 收藏代码
public class SimpleTriggerBean extends TriggerBean {

/** 
 * 时间间隔(秒) 
 */  
private Integer interval;  
/** 
 * 重复次数(默认：-1为无限循环) 
 */  
private Integer repeatCount;  

public Integer getInterval() {  
    return interval;  
}  

public void setInterval(Integer interval) {  
    this.interval = interval;  
}  

public Integer getRepeatCount() {  
    return repeatCount;  
}  

public void setRepeatCount(Integer repeatCount) {  
    this.repeatCount = repeatCount;  
}

}
Java代码 收藏代码
public class SchedulerFactoryBean implements InitializingBean {

protected static Logger logger = Logger.getLogger(SchedulerFactoryBean.class);  
/** 
 * 触发器列表 
 */  
private List<Object> triggers;  
/** 
 * zooKeeper工厂 
 */  
private ZookeeperFactory zooKeeperFactory;  

/** 
 * Spring初始化方法 
 * @throws SchedulerException 
 */  
public void afterPropertiesSet() throws SchedulerException {  
    this.initSchedulerFactory();  
}  

/** 
 * 初始化调度器工厂 
 * @throws SchedulerException 
 */  
public void initSchedulerFactory() throws SchedulerException {  
    //初始化StdSchedulerFactory  
    StdSchedulerFactory schedulerFactory = SchedulerUtils.initStdSchedulerFactory();  
    //获取调度器  
    Scheduler scheduler = schedulerFactory.getScheduler();  
    //装载调度器  
    for(Object triggerObject : this.getTriggers()){  
        if(triggerObject instanceof CronTriggerBean){  
            CronTriggerBean cronTriggerBean = (CronTriggerBean)triggerObject;  
            //获取任务代理类对象  
            JobDetailProxyBean jobDetailProxyBean = cronTriggerBean.getJobDetail();  
            //装配任务  
            JobDetail jobDetail = SchedulerUtils.assemblyJobDetail(jobDetailProxyBean);  
            //设置zooKeeper连接工厂  
            jobDetail.getJobDataMap().put("zooKeeperFactory",this.getZooKeeperFactory());  
            //装配触发器  
            CronTrigger cronTrigger =  SchedulerUtils.assemblyCronTrigger(cronTriggerBean);  
            scheduler.scheduleJob(jobDetail, cronTrigger);

// System.out.println(“CronTriggerBean”);
}else{
SimpleTriggerBean simpleTriggerBean = (SimpleTriggerBean)triggerObject;
//获取任务代理类对象
JobDetailProxyBean jobDetailProxyBean = simpleTriggerBean.getJobDetail();
//装配任务
JobDetail jobDetail = SchedulerUtils.assemblyJobDetail(jobDetailProxyBean);
//设置zooKeeper连接工厂
jobDetail.getJobDataMap().put(“zooKeeperFactory”,this.getZooKeeperFactory());
//装配触发器
SimpleTrigger simpleTrigger = SchedulerUtils.assemblySimpleTrigger(simpleTriggerBean);
scheduler.scheduleJob(jobDetail, simpleTrigger);
// System.out.println(“SimpleTriggerBean”);
}
}

    scheduler.start();  
    logger.info("调度器已启动");  
}  

public List<Object> getTriggers() {  
    return triggers;  
}  

public void setTriggers(List<Object> triggers) {  
    this.triggers = triggers;  
}  

public ZookeeperFactory getZooKeeperFactory() {  
    return zooKeeperFactory;  
}  

public void setZooKeeperFactory(ZookeeperFactory zooKeeperFactory) {  
    this.zooKeeperFactory = zooKeeperFactory;  
}

}

Java代码 收藏代码
package com.ab.scheduling.quartz;

import com.ab.scheduling.quartz.constant.Constant;
import org.apache.curator.RetryPolicy;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.state.ConnectionState;
import org.apache.curator.framework.state.ConnectionStateListener;
import org.apache.curator.retry.ExponentialBackoffRetry;
import org.apache.log4j.Logger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.ZooDefs;
import org.springframework.beans.factory.InitializingBean;

import java.util.Collections;
import java.util.List;

/**

  • Zookeeper 工厂类

  • Date: 14-4-2

  • Time: 下午4:03
    */
    public class ZookeeperFactory implements InitializingBean{

    public static Logger logger = Logger.getLogger(ZookeeperFactory.class);

    /**

    • zookeeper服务地址
      /
      private String hosts;
      /      *
    • 回话的超时时间(毫秒)
      /
      private Integer sessionTimeOut;
      /      *
    • 连接的超时时间(毫秒)
      /
      private Integer connectionTimeOut;
      /      *
    • 命名空间
      /
      private String nameSpace;
      /
    • zookeeper管理对象
      /
      private CuratorFramework zkTools;
      /      *
    • 独享队列节点
      /
      private String monopolyQueueNode;
      /      *
    • 连接状态
      /
      private String connectionState;
      /      *
    • 会话ID
      */
      private long sessionId;

    /**

    • Spring初始化方法
      */
      public void afterPropertiesSet(){
      this.connection();
      this.addListener();
      }

    /**

    • 连接
      */
      public void connection(){
      RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, Integer.MAX_VALUE);
      zkTools = CuratorFrameworkFactory
      .builder()
      .connectString(hosts)
      .namespace(nameSpace)
      .retryPolicy(retryPolicy)
      .connectionTimeoutMs(connectionTimeOut == null ? 30000 : connectionTimeOut)
      .sessionTimeoutMs(sessionTimeOut == null ? 30000 : sessionTimeOut)
      .build();
      zkTools.start();
      }

    /**

    • 连接状态监听
      */
      public void addListener(){
      zkTools.getConnectionStateListenable().addListener(new ConnectionStateListener() {
      public void stateChanged(CuratorFramework client, ConnectionState newState) {
      if (newState.equals(ConnectionState.CONNECTED)) {
      logger.info(“连接”);
      connectionState = “CONNECTED”;
      try {
      sessionId = zkTools.getZookeeperClient().getZooKeeper().getSessionId();
      registerMonopolyQueue();
      } catch (Exception e) {
      logger.error(“注册独占队列失败”);
      }
      }
      if (newState.equals(ConnectionState.RECONNECTED)) {
      logger.info(“重新连接”);
      connectionState = “CONNECTED”;
      try {
      if(sessionId != zkTools.getZookeeperClient().getZooKeeper().getSessionId()) {
      registerMonopolyQueue();
      }
      } catch (Exception e) {
      logger.error(“注册独占队列失败”);
      }
      }
      if (newState.equals(ConnectionState.LOST)) {
      logger.info(“丢失”);
      connectionState = “LOST”;
      }
      if (newState.equals(ConnectionState.SUSPENDED)) {
      logger.info(“暂停”);
      connectionState = “SUSPENDED”;
      }
      if (newState.equals(ConnectionState.READ_ONLY)) {
      logger.info(“只读”);
      connectionState = “READ_ONLY”;
      }
      }
      });
      }

    /**

    • 注册独占队列
      */
      private void registerMonopolyQueue() throws Exception {
      if(zkTools.checkExists().watched().forPath(Constant.MONOPOLY) == null){
      zkTools.create()
      .withMode(CreateMode.PERSISTENT)
      .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
      .forPath(Constant.MONOPOLY);
      logger.info(“创建独享锁队列节点成功！”);
      }
      if(monopolyQueueNode == null || (monopolyQueueNode != null && zkTools.checkExists().forPath(monopolyQueueNode)==null)) {
      monopolyQueueNode = zkTools.create()
      .withMode(CreateMode.EPHEMERAL_SEQUENTIAL)
      .withACL(ZooDefs.Ids.OPEN_ACL_UNSAFE)
      .forPath(Constant.MONOPOLY + Constant.SEPARATOR + Constant.QUEUE_NODE);
      logger.info(“成功加入独享锁队列”);
      }
      }

    /**

    • 获得独占锁的执行权限
    • @return 执行权限标识
    • @throws KeeperException
    • @throws InterruptedException
      */
      public boolean getMonopolyLock() throws Exception {
      boolean flag = false;
      if(connectionState != null && (connectionState.equals(“CONNECTED”) || connectionState.equals(“RECONNECTED”))){
      List nodes = zkTools.getChildren().watched().forPath(Constant.MONOPOLY);
      if(nodes.size() > 0){
      Collections.sort(nodes);
      //判断当前应用是否在队列的第一位
      if((Constant.SEPARATOR + Constant.MONOPOLY + Constant.SEPARATOR + nodes.get(0)).equals(monopolyQueueNode)){
      flag = true;
      }
      }
      }
      return flag;
      }

    /**

    • 关闭连接
      */
      public void close(){
      if(zkTools != null){
      zkTools.close();
      zkTools = null;
      }
      }

    public String getHosts() {
    return hosts;
    }

    public void setHosts(String hosts) {
    this.hosts = hosts;
    }

    public Integer getSessionTimeOut() {
    return sessionTimeOut;
    }

    public void setSessionTimeOut(Integer sessionTimeOut) {
    this.sessionTimeOut = sessionTimeOut;
    }

    public Integer getConnectionTimeOut() {
    return connectionTimeOut;
    }

    public void setConnectionTimeOut(Integer connectionTimeOut) {
    this.connectionTimeOut = connectionTimeOut;
    }

    public String getNameSpace() {
    return nameSpace;
    }

    public void setNameSpace(String nameSpace) {
    this.nameSpace = nameSpace;
    }
    }

Java代码 收藏代码
package com.ab.scheduling.quartz.common;

import com.ab.scheduling.quartz.JobDetailProxyBean;
import com.ab.scheduling.quartz.CronTriggerBean;
import com.ab.scheduling.quartz.SimpleTriggerBean;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.simpl.SimpleThreadPool;

import java.util.Properties;

/**

  • Quartz调度工具类

  • Date: 14-5-15

  • Time: 下午6:10
    */
    public class SchedulerUtils {

    protected static Logger logger = Logger.getLogger(SchedulerUtils.class);

    /**

    • 初始化StdSchedulerFactory

    • @return StdSchedulerFactory
      */
      public static StdSchedulerFactory initStdSchedulerFactory() {
      StdSchedulerFactory schedulerFactory = null;
      try{
      schedulerFactory = (StdSchedulerFactory) Class.forName(StdSchedulerFactory.class.getName()).newInstance();
      Properties mergedProps = new Properties();
      // 设置Quartz线程池设置
      mergedProps.setProperty(StdSchedulerFactory.PROP_THREAD_POOL_CLASS, SimpleThreadPool.class.getName());
      mergedProps.setProperty(“org.quartz.threadPool.threadCount”, Integer.toString(10));

       schedulerFactory.initialize(mergedProps);

      } catch (Exception e){
      logger.error(“初始化StdSchedulerFactory失败”);
      logger.error(e);
      }
      return schedulerFactory;
      }

    /**

    • 装配任务

    • @param jobDetail 任务代理类

    • @return JobDetail
      */
      public static JobDetail assemblyJobDetail(JobDetailProxyBean jobDetail){

      JobBuilder jobBuilder = JobBuilder.newJob(jobDetail.getClass());
      //设置JobDetail身份标识与所属组
      String key = jobDetail.getKey();
      if(StringUtils.isNotBlank(key)){
      jobBuilder = jobBuilder.withIdentity(key, jobDetail.getGroup());
      }else{
      jobBuilder = jobBuilder.withIdentity(IdentityUtils.generatorUUID(“JOB”), jobDetail.getGroup());
      }

      //设置任务描述
      if(StringUtils.isNotBlank(jobDetail.getDescription())){
      jobBuilder = jobBuilder.withDescription(jobDetail.getDescription());
      }

      //设置JobDetail数据参数
      JobDataMap jobDataMap = new JobDataMap();
      jobDataMap.put(“targetObject”,jobDetail.getTargetObject()); //目标对象
      jobDataMap.put(“targetMethod”,jobDetail.getTargetMethod()); //目标方法
      jobDataMap.put(“mode”, jobDetail.getMode()); //运行模式
      jobBuilder = jobBuilder.usingJobData(jobDataMap);

      return jobBuilder.build();
      }

    /**

    • 装配表达式触发器

    • @param cronTriggerBean 表达式触发器

    • @return 表达式触发器
      */
      public static CronTrigger assemblyCronTrigger(CronTriggerBean cronTriggerBean){

      TriggerBuilder triggerBuilder = TriggerBuilder.newTrigger();

      //设置触发器身份标识与所属组
      String key = cronTriggerBean.getKey();
      if(StringUtils.isNotBlank(key)){
      triggerBuilder = triggerBuilder.withIdentity(key, cronTriggerBean.getGroup());
      }else{
      triggerBuilder = triggerBuilder.withIdentity(IdentityUtils.generatorUUID(“CronTrigger”), cronTriggerBean.getGroup());
      }
      //设置描述
      if(StringUtils.isNotBlank(cronTriggerBean.getDescription())){
      triggerBuilder = triggerBuilder.withDescription(cronTriggerBean.getDescription());
      }
      //设置启动时间
      if(StringUtils.isNotBlank(cronTriggerBean.getStartTime())){
      triggerBuilder = triggerBuilder.startAt(DateUtils.StringToDate(cronTriggerBean.getStartTime(), “yyyy-MM-dd HH:mm:ss”));
      }else{
      triggerBuilder = triggerBuilder.startNow(); //当启动时间为空默认立即启动调度器
      }
      //设置结束时间
      if(StringUtils.isNotBlank(cronTriggerBean.getEndTime())){
      triggerBuilder = triggerBuilder.endAt(DateUtils.StringToDate(cronTriggerBean.getEndTime(), “yyyy-MM-dd HH:mm:ss”));
      }
      //设置优先级
      if(cronTriggerBean.getPriority() != null){
      triggerBuilder = triggerBuilder.withPriority(cronTriggerBean.getPriority());
      }

      //设置Cron表达式(不允许为空)与集火指令
      CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronTriggerBean.getCronExpression());
      if(cronTriggerBean.getMisfireInstruction() != null){
      if(cronTriggerBean.getMisfireInstruction() == Trigger.MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY) {
      cronScheduleBuilder = cronScheduleBuilder.withMisfireHandlingInstructionIgnoreMisfires();
      }
      if(cronTriggerBean.getMisfireInstruction() == CronTrigger.MISFIRE_INSTRUCTION_FIRE_ONCE_NOW) {
      cronScheduleBuilder = cronScheduleBuilder.withMisfireHandlingInstructionFireAndProceed();
      }
      if(cronTriggerBean.getMisfireInstruction() == CronTrigger.MISFIRE_INSTRUCTION_DO_NOTHING) {
      cronScheduleBuilder = cronScheduleBuilder.withMisfireHandlingInstructionDoNothing();
      }
      }
      triggerBuilder = triggerBuilder.withSchedule(cronScheduleBuilder);

      return (CronTrigger)triggerBuilder.build();
      }

    /**

    • 装配简单触发器

    • @param simpleTriggerBean 简单触发器

    • @return 简单触发器
      */
      public static SimpleTrigger assemblySimpleTrigger(SimpleTriggerBean simpleTriggerBean){

      TriggerBuilder triggerBuilder = TriggerBuilder.newTrigger();

      //设置触发器身份标识与所属组
      String key = simpleTriggerBean.getKey();
      if(StringUtils.isNotBlank(key)){
      triggerBuilder = triggerBuilder.withIdentity(key, simpleTriggerBean.getGroup());
      }else{
      triggerBuilder = triggerBuilder.withIdentity(IdentityUtils.generatorUUID(“SimpleTrigger”), simpleTriggerBean.getGroup());
      }
      //设置描述
      if(StringUtils.isNotBlank(simpleTriggerBean.getDescription())){
      triggerBuilder = triggerBuilder.withDescription(simpleTriggerBean.getDescription());
      }
      //设置启动时间
      if(StringUtils.isNotBlank(simpleTriggerBean.getStartTime())){
      triggerBuilder = triggerBuilder.startAt(DateUtils.StringToDate(simpleTriggerBean.getStartTime(), “yyyy-MM-dd HH:mm:ss”));
      }else{
      triggerBuilder = triggerBuilder.startNow(); //当启动时间为空默认立即启动调度器
      }
      //设置结束时间
      if(StringUtils.isNotBlank(simpleTriggerBean.getEndTime())){
      triggerBuilder = triggerBuilder.endAt(DateUtils.StringToDate(simpleTriggerBean.getEndTime(), “yyyy-MM-dd HH:mm:ss”));
      }
      //设置优先级
      if(simpleTriggerBean.getPriority() != null){
      triggerBuilder = triggerBuilder.withPriority(simpleTriggerBean.getPriority());
      }

      //设置简单触发器 时间间隔(不允许为空)、执行次数(默认为-1)与集火指令
      SimpleScheduleBuilder simpleScheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(20).withRepeatCount(-1);
      simpleScheduleBuilder = simpleScheduleBuilder.withIntervalInSeconds(simpleTriggerBean.getInterval());
      if(simpleTriggerBean.getRepeatCount() != null){
      simpleScheduleBuilder = simpleScheduleBuilder.withRepeatCount(simpleTriggerBean.getRepeatCount());
      }else{
      simpleScheduleBuilder = simpleScheduleBuilder.withRepeatCount(-1);
      }

      if(simpleTriggerBean.getMisfireInstruction() != null){
      if(simpleTriggerBean.getMisfireInstruction() == Trigger.MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY) {
      simpleScheduleBuilder = simpleScheduleBuilder.withMisfireHandlingInstructionIgnoreMisfires();
      }
      if(simpleTriggerBean.getMisfireInstruction() == SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW) {
      simpleScheduleBuilder = simpleScheduleBuilder.withMisfireHandlingInstructionFireNow();
      }
      if(simpleTriggerBean.getMisfireInstruction() == SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_EXISTING_COUNT) {
      simpleScheduleBuilder = simpleScheduleBuilder.withMisfireHandlingInstructionNextWithExistingCount();
      }
      if(simpleTriggerBean.getMisfireInstruction() == SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT) {
      simpleScheduleBuilder = simpleScheduleBuilder.withMisfireHandlingInstructionNextWithRemainingCount();
      }
      if(simpleTriggerBean.getMisfireInstruction() == SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT) {
      simpleScheduleBuilder = simpleScheduleBuilder.withMisfireHandlingInstructionNowWithExistingCount();
      }
      if(simpleTriggerBean.getMisfireInstruction() == SimpleTrigger.MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT) {
      simpleScheduleBuilder = simpleScheduleBuilder.withMisfireHandlingInstructionNowWithRemainingCount();
      }
      }
      triggerBuilder = triggerBuilder.withSchedule(simpleScheduleBuilder);

      return (SimpleTrigger)triggerBuilder.build();
      }
      }
      spring配置

Java代码 收藏代码

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





























李思苇
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于zookeeper和quartz实现分布式定时调度
让爱远航——当我们老去，该干点嘛！
10-26 1068
目的 利用zookeeper的特性，来控制quartz实现分布式调度，保证quartz的单点运行，同时解除quartz自身分布式部署对数据库的依赖，保证同一时刻只有一个quartz应用在执行任务。 实现方式 利用zk的分布式独占锁，控制quartz应用执行节点，让拿到独占锁的quartz应用执行调度，没有拿到独占锁的quartz处理等待状态。 类图   核心代码   publi...
分布式-调度
厚积薄发
03-20 479
分布式调度
Zookeeper分布式协调服务
最新发布
m0_62689947的博客
08-08 1193
本文简述了，什么是zookeeper，zookeeper提供的文件系统和通知机制，作用，特性，安装，znode节点的存储格式以及什么是分布式系统，分布式系统存在的问题和解决方法
maven ssh+ quartz + zookeeper 实现分布式任务调度的管理界面
07-20
分布式 任务调度系统+管理界面 加入zookeeper管理服务调用 相当于一个任务调度系统 参考开源项目 见附件
quartz 分布式_基于zookeeper和quartz实现分布式定时调度
weixin_39575502的博客
12-07 264
利用zookeeper的特性，来控制quartz实现分布式调度，保证quartz的单点运行，同时解除quartz自身分布式部署对数据库的依赖，保证同一时刻只有一个quartz应用在执行任务。实现方式利用zk的分布式独占锁，控制quartz应用执行节点，让拿到独占锁的quartz应用执行调度，没有拿到独占锁的quartz处理等待状态。类图核心代码public class TriggerBean { ...
基于zookeeper和quartz实现分布式定时调度（二）
淘淘联盟
04-11 1094
最近一直在学习，偶然间翻看了一下博客，发现很多人问我关于基于zookeeper和quartz实现分布式定时调度文章的一些问题。由于本人最近几年都没怎么关注博客，因此也没有做出回复，心里感觉愧对大家。所以抽时间把之前写的东西重新翻了下版。顺便把代码也分享给大家。Quartz相关的知识和类之间的关系，可以参考我之前的一篇文章。 本文对zookeeper的分布式协作相关的代码做了改进。本文中使用临时顺...
基于zookeeper临时顺序节点实现分布式调度
04-11
在本场景中，我们利用Zookeeper的临时顺序节点来实现一个分布式调度解决方案，并结合Quartz进行作业调度。Zookeeper是一个分布式协调服务，而Quartz则是一个强大的、开源的作业调度框架，两者结合能构建出高可用、可...
基于zookeeper+quartz/spring task的分布式任务调度组件，非常小巧，无需任何修改就可以使用
06-05
【作品名称】：基于zookeeper+quartz/spring task的分布式任务调度组件，非常小巧，无需任何修改就可以使spring task具备分布式特性，确保所有任务在集群中不重复，不遗漏的执行。 【适用人群】：适用于希望学习...
基于分布式锁或xxx-job实现分布式任务调度.zip
08-26
本项目可能使用了如ZooKeeper、Redis或Apache Curator等工具来实现分布式锁。这些工具能够提供高可用性和可扩展性，确保在分布式系统中的任务调度一致性。 而“xxx-job”可能指的是某种特定的分布式任务调度框架，...
Springboot 定时任务集群(Quartz方式，利用zookeeper实现分布式锁方式)
weixin_41368339的博客
08-15 9800
■1.Quartz方式(Quartz版本：2.2.3) Quartz的定时任务能力比较强大，它自己就可以实现集群功能。Quartz在实现集群功能时，利用了数据库对任务进行调度，而其使用到的数据库表数据都是自动装填的不用认为管理表数据。我们只需要按照Quartz要求建表即可。所需要建表，Quartz已经帮我们写好了SQL，只需要对照你的数据库找到相应的SQL执行一下即可。 Quartz官网：ht...
zookeeper+schedule实现分布式定时任务
HTslide的博客
09-19 2848
zookeeper+schedule实现分布式定时任务下载zk创建一个springboot项目源码地址 [zk-task](https://github.com/yangzhouhu/zk_task) 下载zk 官网下载地址：https://zookeeper.apache.org/ 我这里下载的是3.4.10 下载解压后在在1路径下将2复制一份并重命名为3，然后编辑3 添加dataDir和dat...
使用zookeeper实现分布式集群定时任务组件
MLTR1的博客
12-12 2137
使用zookeeper实现分布式集群定时任务组件 在我们实现定时任务时，难以达到分布式集群的稳定和高可用。在使用集群方案时，如果触发器也采用单点部署，则在单点发生服务器或是网络故障的情况下，也不能够满足高可用的需要；如果采用多点部署，则会存在定时任务会被执行多次的问题，如果采用同步机智，实现逻辑会比较复杂。有没有一种两全其美的解决方案呢，下面我来介绍如何通过zookeeper实现分布式集群定时任务...
基于zk分布式锁的spring定时任务
chinoukin的博客
07-24 512
环境 1.zk的版本 apache-zookeeper-3.6.1 2.curator的版本2.12.0 实现 引入依赖 <dependency> <groupId>org.apache.zookeeper</groupId> <artifactId>zookeeper</artifactId> <version>3.6.1</version> </depe
基于zookeeper实现分布式锁，解决生产环境多实例部署，定时任务多次加载、执行问题
qs9131的博客
05-31 770
1、场景说明 定时任务在服务启动的时候，需要加载到定时任务容器中，保证服务重启后未执行的定时任务仍能够执行，但是生产环境服务是分布式部署，每个节点上的服务都会将定时任务加载到自己的定时任务容器中，导致同一个定时任务被多次加载、执行。 2、问题分析 可以使用分布式锁，在服务启动的时候获取锁，获取到锁的服务将定时任务添加到定时任务容器中，没有获取到锁的不会将定时任务添加到定时任务容器中，我们只要保证只有一个服务获取到锁就可保证定时任务只被一个服务加载。 分布式锁选用redis实现分析 redis分布式锁
2种基于简单定时任务实现分布式定时任务的技术解决方案（zookeeper、redis和内联MQ）
风雷恒，君子以立不易方
01-14 7172
最近项目中，需要实现分布式的定时任务，结合现有的中间件和技术，设计出了2种简单分布式定时任务的实现（这里的前提是定时任务是可拆分的） 需求背景：由于DB需要通过定时任务执行数据清理，每天需要清理N个分库M张分表的线下渠道的数据。（N>20,M>=10） 所以初步设计的定时任务是拆分成了N*M个子任务，假设服务器的数量大于N*M。关键点就是如何实现分布式，让每个服务器都利用起来执行任务，以下是设
基于zookeeper的分布式定时该怎么构建
qq_38028979的博客
03-09 2798
公司有一个单独跑各种定时的一个项目，最近总是频繁的出现故障，主要的原因就是机器的性能问题。 确实一台4核8G的机器，要负责上百个定时任务，有的任务线程十分的频繁，随着后面业务的拓展，这种单机的模式显然已经不能满足后续的需求。 来吧，那就开始重构吧。 重构的大体思路就是，由单机版重构为分布式形式，用拓展的思路，堆服务器的套路，解决后面无穷无尽的需求。 因为单位用的PRC架构是比较流行的Zookeeper+dubbo，zk作为优秀的分布式管理平台，做这种分布式的定时任务，那简直再适合不过了。 为了演示方便，我就
【1】基于quartz框架和Zookeeper实现集群化定时任务系统
weixin_34409357的博客
04-20 216
（1）quartz本身可以支持集群化，是基于数据库做协调，现在构想基于zookeeper做协调实现集群化定时系统 流程图如下： ...
zookeeper初体验之关于解决quartz重复执行任务的一种思路
weixin_30480075的博客
08-05 198
前阵子工作中遇到了一个很麻烦的问题。本人所在的项目组做了一个机遇quartz集群的任务系统。通俗点讲就是用quartz框架（quartz是一款能跑定时任务的框架支持复杂的时间表达式）来执行定时任务。但是这里定时任务的并发数很多，就出现了一个问题，同一个trigger被多个机器重复的触发了，这就造成了执行的任务数目比预期的多很多。领导就让我处理这个问题。开始我以为是这个框架本身的配置有问题，结果翻了...
Elastic-Job分布式任务调度实战教程：原理与项目实战
Elastic-Job是由当当网基于Quartz框架进行二次开发的高性能分布式任务调度解决方案，它强调了任务的弹性执行和高可用性，通过Zookeeper实现分布式协调，确保任务的可靠分片。 课程的核心内容包括以下几个部分： 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值