分布式调试问题

分布时调试,即在分布式环境下定时任务的处理

一、定时任务的场景

   定时任务: 每隔一定时间/特定某一时间执行

  • 订单审核、出库
  • 订单超时⾃动取消、⽀付退款
  • 礼券同步、⽣成、发放作业
  • 物流信息推送、抓取作业、退换货处理作业
  • 数据积压监控、⽇志监控、服务可⽤性探测作业
  • 定时备份数据
  • ⾦融系统每天的定时结算
  • 数据归档、清理作业
  • 报表、离线数据分析作业

二、分布式调度

      含义包含两层

  • 运行在分布式集群环境下的调试任务 (同一个定时任务,程序部署多份,同一时刻只有一个定时任务在执行
  • 分布式调度 -> 定时任务的分布式-> 定时任务的拆分(即为把⼀个⼤的作业任务拆分为多个⼩的作业任务,同时执⾏)

三、定时任务与消息队列的区别

共同点

  •      异步处理

       比如注册、下单事件

  •      应用解耦

     不管定时任务作业还是MQ都可以作为两个应⽤之间的⻮轮实现应⽤解耦,这个⻮轮可以中转数据,当然单体服务不需要考虑这些,服务拆分的时候往往都会考虑

  •    流量削峰

双⼗⼀的时候,任务作业和MQ都可以⽤来扛流量,后端系统根据服务能⼒定时处理订单或者从MQ抓取订单抓取到⼀个订单到来事件的话触发处理,对于前端⽤户来说看到的结果是已经下单成功了,下单是不受任何影响的

不同点

  • 定时任务作业是时间驱动,⽽MQ是事件驱动;
  • 时间驱动是不可代替的,⽐如⾦融系统每⽇的利息结算,不是说利息来⼀条(利息到来事件)就算⼀下,⽽往往是通过定时任务批量计算;
  • 所以,定时任务作业更倾向于批处理, MQ倾向于逐条处理
     

四、定时任务的实现方式

  • 任务调度框架Quartz
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

/**
 * @description Quartz简单示例
 */
public class QuartzMan {

    /**
     * 创建任务调试器
     * @return
     * @throws SchedulerException
     */
    private static Scheduler createScheduler() throws SchedulerException {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        return schedulerFactory.getScheduler();
    }

    /**
     *  创建一个任务
     * @return
     */
    private static JobDetail createJob(){
        JobBuilder jobBuilder = JobBuilder.newJob(YaronJob.class);
        jobBuilder.withIdentity("jobName","YaronYunJob");
        return jobBuilder.build();
    }

    /**
     * 3、创建任务的时间触发器
     *
     * cron表达式由七个位置组成,空格分隔
     * 1、Seconds(秒)  0~59
     * 2、Minutes(分)  0~59
     * 3、Hours(小时)  0~23
     * 4、Day of Month(天)1~31,注意有的月份不足31天
     * 5、Month(月) 0~11,或者 JAN,FEB,MAR,APR,MAY,JUN,JUL,AUG,SEP,OCT,NOV,DEC
     * 6、Day of Week(周)  1~7,1=SUN或者  SUN,MON,TUE,WEB,THU,FRI,SAT
     * 7、Year(年)1970~2099  可选项
     *示例:
     * 0 0 11 * * ? 每天的11点触发执行一次
     * 0 30 10 1 * ? 每月1号上午10点半触发执行一次
     */
    private static Trigger createTrigger(){
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("triggerName","YaronYunTrigger")
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule("*/1 * * * * ?")).build();
        return trigger;
    }

    public static void main(String[] args) throws Exception {
        // 1. 创建任务调试器  
        Scheduler scheduler = createScheduler();
        // 2. 创建一个任务   
        JobDetail job = createJob();
        // 3. 创建任务的时间触发器 
        Trigger trigger = createTrigger();
        // 4. 使用  任务调试器  根据 时间触发器  执行任务
        scheduler.scheduleJob(job,trigger);
        scheduler.start();
    }
}
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @description 具体的任务类
 */
public class YaronJob implements Job {
    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("当前时间是: " + sdf.format(new Date()));
    }
}

五、分布式调度框架Elastic-Job

Elastic-Job是当当⽹开源的⼀个分布式调度解决⽅案,基于Quartz⼆次开发的,由两个相互独⽴的⼦项⽬Elastic-Job-Lite和Elastic-Job-Cloud组成. Elastic-Job-Lite定位为轻量级⽆中⼼化解决⽅案,使⽤Jar包的形式提供分布式任务的协调服务,⽽Elastic-Job-Cloud⼦项⽬需要结合Mesos以及Docker在云环境下使⽤
github地址: https://github.com/elasticjob

maven坐标

<dependency>
     <groupId>com.dangdang</groupId>
     <artifactId>elastic-job-lite-core</artifactId>
      <version>2.1.5</version>
</dependency>

1. 主要功能

  • 分布式调度协调

在分布式环境中,任务能够按指定的调度策略执⾏,并且能够避免同⼀任务多实例重复执⾏

  • 丰富的调度策略

基于成熟的定时任务作业框架Quartz cron表达式执⾏定时任务

  • 弹性扩容缩容

当集群中增加某⼀个实例,它应当也能够被选举并执⾏任务;当集群减少⼀个实例时,它所执⾏的任务能被转移到别的实例来执⾏。

  • 失效转移

某实例在任务执⾏失败后,会被转移到其他实例执⾏

  • 错过执⾏作业重触发

若因某种原因导致作业错过执⾏,⾃动记录错过执⾏的作业,并在上次作业完成后⾃动触发。

  • ⽀持并⾏调度

⽀持任务分⽚,任务分⽚是指将⼀个任务分为多个⼩任务项在多个实例同时执⾏。

  • 作业分⽚⼀致性

当任务被分⽚后,保证同⼀分⽚在分布式环境中仅⼀个执⾏实例

2. 定时任务举例

  需求: 每隔两秒钟执⾏⼀次定时任务(resume表中未归档的数据归档到resume_bak表中,每次归档1条记录)

1) resume_bak和resume表结构完全⼀样
2) resume表中数据归档之后不删除,只将state置为"已归档"

  • 数据准备

DROP TABLE IF EXISTS `resume`;

CREATE TABLE `resume` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`sex` varchar(255) DEFAULT NULL,
`phone` varchar(255) DEFAULT NULL,
`address` varchar(255) DEFAULT NULL,
`education` varchar(255) DEFAULT NULL,
`state` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1001 DEFAULT CHARSET=utf8;

SET FOREIGN_KEY_CHECKS = 1;

DROP TABLE IF EXISTS `resume_bak`;

CREATE TABLE `resume_bak` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`sex` varchar(255) DEFAULT NULL,
`phone` varchar(255) DEFAULT NULL,
`address` varchar(255) DEFAULT NULL,
`education` varchar(255) DEFAULT NULL,
`state` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1001 DEFAULT CHARSET=utf8;
  • 代码介绍

  • JdbcUtil JDBC操作
  • InsertResumeData 数据准备
  • ArchivieJob ElasticJobLite定时任务业务逻辑
  • ElasticJobMain ElasticJob主类
import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @description JDBC操作
 */
public class JdbcUtil {
    //url
    private static String url = "jdbc:mysql://localhost:3306/job?characterEncoding=utf8&useSSL=false";
    //user
    private static String user = "root";
    //password
    private static String password = "123456";
    //驱动程序类
    private static String driver = "com.mysql.jdbc.Driver";

    static {
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() {
        try {
            return DriverManager.getConnection(url, user,password);
        }
        catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void close(ResultSet rs, PreparedStatement ps,
                             Connection con) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (ps != null) {
                    try {
                        ps.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    } finally {
                        if (con != null) {
                            try {
                                con.close();
                            } catch (SQLException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }

    public static void executeUpdate(String sql,Object...obj) {
        Connection con = getConnection();
        PreparedStatement ps = null;
        try {
            ps = con.prepareStatement(sql);
            for (int i = 0; i < obj.length; i++) {
                ps.setObject(i + 1, obj[i]);
            }
            ps.executeUpdate();} catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(null, ps, con);
        }
    }
    public static List<Map<String,Object>> executeQuery(String sql, Object...obj) {
        Connection con = getConnection();
        ResultSet rs = null;
        PreparedStatement ps = null;
        try {
            ps = con.prepareStatement(sql);
            for (int i = 0; i < obj.length; i++) {
                ps.setObject(i + 1, obj[i]);
            }
            rs = ps.executeQuery();
            List<Map<String, Object>> list = new ArrayList<>();
            int count = rs.getMetaData().getColumnCount();
            while (rs.next()) {
                Map<String, Object> map = new HashMap<String,
                                        Object>();
                for (int i = 0; i < count; i++) {
                    Object ob = rs.getObject(i + 1);
                    String key = rs.getMetaData().getColumnName(i
                            + 1);
                    map.put(key, ob);
                }
                list.add(map);
            }
            return list;
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            close(rs, ps, con);
        }
        return null;
    }
}
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

/**
 * @description 数据准备
 */
public class InsertResumeData {

    public static void main(String[] args) throws Exception{
        Connection connection = JdbcUtil.getConnection();
        Random random = new Random();
        List<String> nameList = Arrays.asList("王小虎","张力","张小二","王总","李雪玲","范宝宝","弦子");
        int nameLen = nameList.size();

        List<String> sexList = Arrays.asList("男","女","你懂的");
        int sexLen = sexList.size();

        List<String> addressList = Arrays.asList("北京","上海","成都","郑州","昌都","呼伦贝尔");
        int addressLen = addressList.size();

        List<String> educationList = Arrays.asList("小学","初中","高中","本科","硕士");
        int educationLen = educationList.size();

        String state = "未归档";
        PreparedStatement preparedStatement = null;

        for (int times = 0; times < 1000; times++) {
            String name = nameList.get(random.nextInt(nameLen)) + random.nextInt(1000);
            String sex = sexList.get(random.nextInt(sexLen));
            StringBuffer phoneBuiler = new StringBuffer();
            for (int i = 0; i < 12; i++) {
                phoneBuiler.append(random.nextInt(10));
            }
            String phone = phoneBuiler.toString();
            String address = addressList.get(random.nextInt(addressLen));
            String education = educationList.get(random.nextInt(educationLen));

            preparedStatement = connection.prepareStatement("insert into resume(name,sex,phone,address,education,state) values (?,?,?,?,?,?)");

            preparedStatement.setString(1, name);
            preparedStatement.setString(2, sex);
            preparedStatement.setString(3, phone);
            preparedStatement.setString(4, address);
            preparedStatement.setString(5, education);
            preparedStatement.setString(6, state);

            preparedStatement.execute();
        }
    }
}

 生成的数据部分如下 

mport com.dangdang.ddframe.job.api.ShardingContext;
import com.dangdang.ddframe.job.api.simple.SimpleJob;
import java.util.List;
import java.util.Map;

/**
 * @description ElasticJobLite定时任务业务逻辑
 */
public class ArchivieJob implements SimpleJob {

    /**
     * 任务详情  resume表中未归档的数据归档到resume_bak表中,每次归档1条记录
     * @param shardingContext
     */
    @Override
    public void execute(ShardingContext shardingContext) {

        int shardingItem = shardingContext.getShardingItem();
        System.out.println("--------------> 当前分片: "+ shardingItem);

        // 根据 学历 education的不同,来让不同的分片去处理数据
        String educationParam = shardingContext.getShardingParameter();

        // 1. 从resum表中查询出 未归档的记录
        String selectSql = String.format("select * from resume where state = '%s' and education = '%s' limit 1","未归档",educationParam);
        List<Map<String, Object>> mapList = JdbcUtil.executeQuery(selectSql);
        if (null == mapList || 0 == mapList.size()){
            System.out.println("数据已经 处理完毕!");
            return;
        }
        Map<String, Object> stringObjectMap = mapList.get(0);
        long id = (long)stringObjectMap.get("id");
        String name = String.valueOf(stringObjectMap.get("name"));
        String education = String.valueOf(stringObjectMap.get("education"));
        System.out.println("id: "+ id+"\tname: "+name+"\teducation:"+education);

        // 2. "未归档"  -> 归档
        String updateSql = String.format("update resume set state='%s' where id=?","已归档");
        JdbcUtil.executeUpdate(updateSql,id);

        // 3. 归档这条记录,把这条记录插入 resume_bak表中
        String insertSql = "insert into resume_bak select * from resume where id =?";
        JdbcUtil.executeUpdate(insertSql,id);
    }
}
import com.dangdang.ddframe.job.config.JobCoreConfiguration;
import com.dangdang.ddframe.job.config.simple.SimpleJobConfiguration;
import com.dangdang.ddframe.job.lite.api.JobScheduler;
import com.dangdang.ddframe.job.lite.config.LiteJobConfiguration;
import com.dangdang.ddframe.job.reg.base.CoordinatorRegistryCenter;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperConfiguration;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;

/**
 * @description ElasticJob主类
 */
public class ElasticJobMain {

    public static void main(String[] args) {
        // 配置 分布式协调服务(注册中心)
        ZookeeperConfiguration zkConf =
                new ZookeeperConfiguration("127.0.0.1:2181","archivieJob-zk-job");
        CoordinatorRegistryCenter resCenter = new ZookeeperRegistryCenter(zkConf);
        resCenter.init();

        // 配置任务(时间事件 定时任务业务逻辑 调试器)
        // shardingItemParameters 分片参数,用来说明哪个分片 说明 哪个任务
        JobCoreConfiguration jobConf = JobCoreConfiguration.newBuilder("archive-job", "*/2 * * * * ?",
                5)
                .shardingItemParameters(
                        String.format("0=%s,1=%s,2=%s,3=%s,4=%s","小学","初中","高中","本科","硕士")
                ).build();
        SimpleJobConfiguration simpleJobConfiguration = new SimpleJobConfiguration(jobConf, ArchivieJob.class.getName());

        // overwrite(true) 当zk变化时,会进行配置的覆盖
        JobScheduler jobScheduler = new JobScheduler(resCenter,
                LiteJobConfiguration.newBuilder(simpleJobConfiguration)
                        .overwrite(true).build());
        jobScheduler.init();
    }
}

测试
1)可先启动⼀个进程,然后再启动⼀个进程(两个进程模拟分布式环境下,通⼀个定时任务部署了两份在⼯作)
2)两个进程逐个启动,观察现象   

           初始化时所有分片 的任务都集中到开启的实例中,  在开启另一个实例后,分片任务会分配到新启动的实例上,  两个实例运行的任务不相同,这就保证了任务不会被重复运行
3)关闭其中执⾏的进程,观察现象

         现象和2)类似          

 

  • Leader节点选举机制

每个Elastic-Job的任务执⾏实例App作为Zookeeper的客户端来操作ZooKeeper的znode
(1)多个实例同时创建/leader节点
(2) /leader节点只能创建⼀个,后创建的会失败,创建成功的实例会被选为leader节点,执⾏任务

 Elastic-Job的任务分片机制说明 

  • ElasticJob可以把作业分为多个的task(每⼀个task就是⼀个任务分⽚),每⼀个task交给具体的⼀个机器实例去处理(⼀个机器实例是可以处理多个task的),但是具体每个task执⾏什么逻辑由我们⾃⼰来指定  上述 ArchivieJob 代码中可见分片 的设置 
  • Strategy策略定义这些分⽚项怎么去分配到各个机器上去,默认是平均去分,可以定制,⽐如某⼀个机器负载 ⽐较⾼或者预配置⽐较⾼,那么就可以写策略。分⽚和作业本身是通过⼀个注册中⼼协调的,因为在分布式环境下,状态数据肯定集中到⼀点,才可以在分布式中沟通

注意:
1)分⽚项也是⼀个JOB配置,修改配置,重新分⽚,在下⼀次定时运⾏之前会重新调⽤分⽚算法,那么这个分⽚算法的结果就是:哪台机器运⾏哪⼀个⼀⽚,这个结果存储到zk中的,主节点会把分⽚给分好放到注册中⼼去,然后执⾏节点从注册中⼼获取信息(执⾏节点在定时任务开启的时候获取相应的分⽚)。
2)如果所有的节点挂掉值剩下⼀个节点,所有分⽚都会指向剩下的⼀个节点,这也是ElasticJob的⾼可⽤。

 

如下所示 启动 zooInspector,观察上述Elastsic-Job的运行情况

当前 是启动了3个 实例 去运行 5 个分片的任务,这5个分片 任务会尽可能 的 平均分配 到3个运行实例当中

3个实例上运行的分片情况

 

  • Elastic-Job-Lite轻量级去中⼼化的特点

 

 

 

 

 


 

 

      

 

 

 

 

 

 

 

 

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值