LTS简介以及与SpringBoot的简单集成

最新推荐文章于 2024-08-09 07:58:43 发布
最新推荐文章于 2024-08-09 07:58:43 发布
阅读量4.7k 收藏 19
点赞数 1
分类专栏： 随笔 文章标签： LTS 分布式任务调度框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42815754/article/details/91047418
版权

LTS简介以及与SpringBoot的简单集成

一 什么是LTS

关于定时任务，虽然Spring提供了基于注解@EnableScheduling @Scheduled的实现方式。其实现是通过线程池ScheduledThreadPoolExecutor的方式，具体这里就不多做介绍啦，有兴趣的小伙伴可以自行了解下~
但是以上只适用于单机的情况下，如果是分布式项目的话，就会显得有些力不从心了。所以这里给大家介绍一个分布式任务调度框架 -> LTS，它是阿里巴巴的一个开源项目。
借用官方文档的一句话就是：

LTS 着力于解决分布式任务调度问题，将任务的提交者和执行者解耦，解决任务执行的单点故障，支持动态扩容，出错重试等机制。代码程序设计上，参考了优秀开源项目Dubbo，Hadoop的部分思想。

二 LTS架构总览

以下图片来自官方文档
在这里插入图片描述
乍一看这都啥跟啥啊，有点麻烦的样子，别急，且听我慢慢道来，咱们看图说话。

从上图可以看出，LTS包含以下几种节点类型：

  1. JobClient -> 负责提交任务，并接收任务执行反馈结果。
  2. JobTracker -> 负责任务调度，接收并分配任务。
  3. TaskTracker -> 负责执行任务，执行完之后将任务执行结果反馈给 JobTracker。
  4. Monitor -> 负责收集各个节点的监控信息，包括任务监控信息，节点JVM监控信息。
  5. Admin -> 则是后台管理，负责节点管理，任务队列管理，监控管理等。

LTS的这五种节点都是无状态的，都可以部署多个，动态扩容，来实现负载均衡，实现更大的负载量, 并且框架采用FailStore策略使LTS具有很好的容错能力。

既然节点可以以集群的方式部署，那么肯定少不了注册中心啦！如上图第一行所示：
注册中心可以使Zookeeper或者Redis，官方推荐使用Zookeeper作为注册中心(划重点，要考的)。

继续看图，FailStore -> 顾名思义就是失败存储，主要用于在部分场景远程RPC调用失败的情况，采取现存储本地KV文件系统，待远程通信恢复的时候再进行数据补偿。
主要用于节点容错，当远程数据交互失败之后，存储在本地，等待远程通信恢复的时候，再将数据提交。

接着是FailStore的右边，有个QueueManager -> 任务队列 ，主要用于存储任务数据和任务执行日志等。支持mysql和mongodb实现，官方推荐使用mysql，当然也可以自己扩展实现，例如Oracle。

然后是节点组NodeGroup，每个节点组的节点都是平等的，对外提供相同的服务。每个节点组中都有一个master节点，动态选举得到的。

最后是ClusterName，也就是LTS集群，就如上图所示，整个图就是一个集群，包含LTS的五种节点。

OK，大概了解了LTS的架构之后，让我们继续了解一下LTS的执行流程吧！

三 LTS执行流程

以下图片来自官方文档
在这里插入图片描述
说了这么多，那么LTS都支持什么类型的任务呢？目前支持以下几种任务：

实时任务，提交之后就会马上执行的任务；
定时任务，在指定时间点执行的任务，譬如 今天3点执行（单次）。
Cron任务：CronExpression，和quartz类似（但是不是使用quartz实现的）譬如 0 0/1 * ?
Repeat任务(重复任务)：譬如每隔5分钟执行一次，重复50次就停止。

由于篇幅有限，关于LTS的介绍就先到这里，更多介绍小伙伴可以参阅 官方文档 ~
LTS gihub地址 -> LTS项目源码
LTS 例子地址 -> LTS使用实例

你可以直接下载LTS使用实例，按照官方指示，在本地运行起来。 里面集成了spring以及springboot等的使用~

好了，接下来，咱们就正式进入SprigBoot和LTS的集成。

四 SpringBoot集成LTS

特别说明：本示例的主要目的仅仅是告诉大家如何使用LTS，所以偷了个懒，将所有节点都揉合到了一个工程，实际项目是分开部署的，因需而定。
整个工程其实很简单，不信你看：
在这里插入图片描述

1. 准备工作
  • 新建SpringBoot工程(这不废话吗);
  • 导入相应的依赖，如果你是导入的官方example，则不需要做这些工作。如果是新建SpringBoot工程，我的版本是 2.2.1.RELEASE，则不要直接把官方的example pom依赖复制过来，因为版本兼容问题，可能会导致错误~ 以下是我的pom文件依赖
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--lts-->
        <dependency>
            <groupId>com.github.ltsopensource</groupId>
            <artifactId>lts</artifactId>
            <version>1.7.0</version>
        </dependency>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.25.Final</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>
        <dependency>
            <groupId>org.mapdb</groupId>
            <artifactId>mapdb</artifactId>
            <version>2.0-beta10</version>
        </dependency>
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.14</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.26</version>
        </dependency>
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.20.0-GA</version>
        </dependency>

    </dependencies>

注意：如果你用的是Redis作为注册中心，mongodb作为任务队列，那么请引入相应的依赖，我这里用的是Zookeeper和mysql。

  • 然后是配置文件信息，如下：
##########################################
# jobclient->负责提交任务以及接收任务执行结果 #
##########################################
#集群名称
lts.jobclient.cluster-name=test_cluster
#注册中心
lts.jobclient.registry-address=zookeeper://127.0.0.1:2181
#JobClient节点组名称
lts.jobclient.node-group=test_jobClient
#是否使用RetryClient
lts.jobclient.use-retry-client=true
#失败存储，用于服务正常后再次执行(容错处理)
lts.jobclient.configs.job.fail.store=mapdb

#######################################
# jobtracker->负责调度任务 接收并分配任务 #
#######################################
lts.jobtracker.cluster-name=test_cluster
lts.jobtracker.listen-port=35001
lts.jobtracker.registry-address=zookeeper://127.0.0.1:2181
lts.jobtracker.configs.job.logger=mysql
lts.jobtracker.configs.job.queue=mysql
lts.jobtracker.configs.jdbc.url=jdbc:mysql://127.0.0.1:3306/lts
lts.jobtracker.configs.jdbc.username=root
lts.jobtracker.configs.jdbc.password=root

###########################################################
# tasktracker->负责执行任务 执行完任务将执行结果反馈给JobTracker #
###########################################################
lts.tasktracker.cluster-name=test_cluster
lts.tasktracker.registry-address=zookeeper://127.0.0.1:2181
#TaskTracker节点组默认是64个线程用于执行任务
#lts.tasktracker.work-threads=64
lts.tasktracker.node-group=test_trade_TaskTracker
#lts.tasktracker.dispatch-runner.enable=true
#lts.tasktracker.dispatch-runner.shard-value=taskId
lts.tasktracker.configs.job.fail.store=mapdb


################################################################
# jmonitor->负责收集各个节点的监控信息，包括任务监控信息，节点JVM监控信息 #
################################################################
lts.monitor.cluster-name=test_cluster
lts.monitor.registry-address=zookeeper://127.0.0.1:2181
lts.monitor.configs.job.logger=mysql
lts.monitor.configs.job.queue=mysql
lts.monitor.configs.jdbc.url=jdbc:mysql://127.0.0.1:3306/lts
lts.monitor.configs.jdbc.username=root
lts.monitor.configs.jdbc.password=root

肯定有人要问了，哪来的lts数据库，所以，还需要新建一个数据库，名为lts ，其他不用管，因为表信息在项目启动之后会自动创建的。

除了application.properties配置文件，还需要新建log4j.properties日志配置文件，如下：

log4j.rootLogger=INFO,stdout
log4j.appender.stdout.Threshold=INFO
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d [%t] (%F:%L) %-5p %c %x - %m%n

说明：以上配置信息，均可以在官方示例lts-example找到。

完成以上准备工作之后，接着便是实现任务提交以及任务执行了。

2. 启动类设置

其实很简单，加上相应的注解即可：

@SpringBootApplication
@EnableJobClient        //JobClient
@EnableTaskTracker      //TaskTracker
@EnableJobTracker       //JobTracker 
@EnableMonitor          //Monitor
public class LtstestApplication {

    public static void main(String[] args) {
        SpringApplication.run(LtstestApplication.class, args);
    }

}

哈哈，是不是和集成微服务很像啊，也是需要添加相应的注解，具体作用一目了然，就不多做赘述啦~

3. JobClient提交任务

关于Jobclient使用的官方建议：

一般在一个JVM中只需要一个JobClient实例即可，不要为每种任务都新建一个JobClient实例，这样会大大的浪费资源，因为一个JobClient可以提交多种任务。

本示例中，我直接写在了TestController中，模拟了提交两个不同的任务：

 	@Autowired
    private JobClient jobClient;	

	@GetMapping("test01")
    public Map<String, Object> test01() {
        //模拟提交一个任务
        Job job = new Job();
        job.setTaskId("task-AAAAAAAAAAAAAAA");
        job.setCronExpression("0/3 * * * * ?");
        //设置任务类型 区分不同的任务 执行不同的业务逻辑
        job.setParam("type", "aType");
        job.setNeedFeedback(true);
        //任务触发时间 如果设置了 cron 则该设置无效
//        job.setTriggerTime(DateUtils.addDay(new Date(), 1).getTime());
        //任务执行节点组
        job.setTaskTrackerNodeGroup("test_trade_TaskTracker");
        //当任务队列中存在这个任务的时候，是否替换更新
        job.setReplaceOnExist(false);
        Map<String, Object> submitResult = new HashMap<String, Object>(4);
        try {
            //任务提交返回值 response
            Response response = jobClient.submitJob(job);
            submitResult.put("success", response.isSuccess());
            submitResult.put("msg", response.getMsg());
            submitResult.put("code", response.getCode());
        } catch (Exception e) {
            log.error("提交任务失败", e);
            throw new RuntimeException("提交任务失败");
        }
        return submitResult;
    }

    @GetMapping("test02")
    public Map<String, Object> test02() {
        //模拟提交一个任务
        Job job = new Job();
        job.setTaskId("task-BBBBBBBBBBBBBBB");
        job.setCronExpression("0/6 * * * * ?");
        //设置任务类型 区分不同的任务 执行不同的业务逻辑
        job.setParam("type", "bType");
        job.setNeedFeedback(true);
        //任务触发时间 如果设置了 cron 则该设置无效
//        job.setTriggerTime(DateUtils.addDay(new Date(), 1).getTime());
        //任务执行节点组
        job.setTaskTrackerNodeGroup("test_trade_TaskTracker");
        //当任务队列中存在这个任务的时候，是否替换更新
        job.setReplaceOnExist(false);
        Map<String, Object> submitResult = new HashMap<String, Object>(4);
        try {
            Response response = jobClient.submitJob(job);
            submitResult.put("success", response.isSuccess());
            submitResult.put("msg", response.getMsg());
            submitResult.put("code", response.getCode());
        } catch (Exception e) {
            log.error("提交任务失败", e);
            throw new RuntimeException("提交任务失败");
        }
        return submitResult;
    }

注意看：JobClient我们可以直接引入，然后构建一个Job，通过JobClient进行提交。任务提交之后，JobTracker会对任务进行分发，分发方式有如下两种：

TaskTracker会定时发送pull请求给JobTracker, 默认1s一次, 在发送pull请求之前，会检查当前TaskTracker是否有可用的空闲线程，如果没有则不会发送pull请求，同时也会检查本节点机器资源是否足够，主要是检查cpu和内存使用率，默认超过90%就不会发送pull请求，当JobTracker收到TaskTracker节点的pull请求之后，再从任务队列中取出相应的已经到了执行时间点的任务 push给TaskTracker，这里push的个数等于TaskTracker的空余线程数。

还有一种途径是，每个TaskTracker线程处理完当前任务之后，在反馈给JobTracker的时候，同时也会询问JobTracker是否有新的任务需要执行，如果有JobTracker会同时返回给TaskTracker一个新的任务执行。所以在任务量足够大的情况下，每个TaskTracker基本上是满负荷的执行的。

4. TaskTracker执行任务

关于TaskTracker使用的官方建议：

一个JVM一般也尽量保持只有一个TaskTracker实例即可，多了就可能造成资源浪费。
当遇到一个TaskTracker要运行多种任务的时候，在一个JVM中，最好使用一个TaskTracker去运行多种任务，因为一个JVM中使用多个TaskTracker实例比较浪费资源（当然当你某种任务量比较多的时候，可以将这个任务单独使用一个TaskTracker节点来执行）。

上面提交了两个任务，分别是任务A和任务B，所以这里演示的是一个TaskTracker执行多种不同的任务。
任务的执行必须实现JobRunner接口，如下任务A：

public class JobRunnerA implements JobRunner {

    @Override
    public Result run(JobContext jobContext) throws Throwable {
        //  TODO A类型Job的逻辑
        System.out.println("我是Runner A");
        return null;
    }

}

任务B同理，就不重复贴出代码了。

需要指出的是，在SpringBoot中，任务的执行需要添加@JobRunner4TaskTracker注解，但是有且只能有一个@JobRunner4TaskTracker注解。所以，对于同一个TaskTracker执行不同的任务，需要进行调度执行，如下：

/**
 * 总入口，在 taskTracker.setJobRunnerClass(JobRunnerDispatcher.class)
 * JobClient 提交 任务时指定 Job 类型  job.setParam("type", "aType")
 */
@JobRunner4TaskTracker
public class JobRunnerDispatcher implements JobRunner {

    private static final Logger log = LoggerFactory.getLogger(JobRunnerDispatcher.class);

    private static final ConcurrentHashMap<String/*type*/, JobRunner>
            JOB_RUNNER_MAP = new ConcurrentHashMap<String, JobRunner>();

    static {
        JOB_RUNNER_MAP.put("aType", new JobRunnerA()); // 也可以从Spring中拿
        JOB_RUNNER_MAP.put("bType", new JobRunnerB());
    }

    @Override
    public Result run(JobContext jobContext) throws Throwable {
        Job job = jobContext.getJob();
        String type = job.getParam("type");
        return JOB_RUNNER_MAP.get(type).run(jobContext);
    }

}

说明：该JobRunnerDispatcher 类同样实现了JobRunner接口，并且添加了 @JobRunner4TaskTracker注解，表示该类才是真正会执行任务的地方。通过该类，实现不同的任务执行。

实际上，到这里基本整个LTS任务从提交到执行就已经完成了，也就是简单的集成完成了。
可以直接启动项目了~

5. master节点监听以及任务完成处理类

这个不必多说，直接看代码好了(来自lts-example)：

/**
 * 主节点监听
 */
@MasterNodeListener
public class MasterNodeChangeListener implements MasterChangeListener {

    private static final Logger log = LoggerFactory.getLogger(MasterNodeChangeListener.class);


    /**
     * @param master   master节点
     * @param isMaster 表示当前节点是不是master节点
     */
    @Override
    public void change(Node master, boolean isMaster) {
        // 一个节点组master节点变化后的处理 , 譬如我多个JobClient， 但是有些事情只想只有一个节点能做。
        if (isMaster) {
            log.info("我变成了节点组中的master节点了， 恭喜， 我要放大招了");
        } else {
            log.info(StringUtils.format("master节点变成了{}，不是我，我不能放大招，要猥琐", master));
        }
    }

}

/**
 * 任务完成处理类
 */
@Component
public class JobCompletedHandlerImpl implements JobCompletedHandler {

    private static final Logger log = LoggerFactory.getLogger(JobCompletedHandlerImpl.class);

    @Override
    public void onComplete(List<JobResult> jobResults) {
        //对任务执行结果进行处理 打印相应的日志信息
        if (CollectionUtils.isNotEmpty(jobResults)) {
            for (JobResult jobResult : jobResults) {
                String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
                log.info("任务执行完成taskId={}, 执行完成时间={}, job={}",
                        jobResult.getJob().getTaskId(), time, jobResult.getJob().toString());
            }
        }
    }

}
6. Admin后台管理

这个直接去官方源码复制下来admin模块，然后丢到Tomcat本地启动就OK了~

7.项目启动

启动项目，分别调用接口 /test01() /test02()
在这里插入图片描述
可以看到，master节点的变化是在监听中的，以及不同的任务分别在执行。
OK，那么这些信息，在后台管理能看到吗，答案是肯定的如图：
在这里插入图片描述
可以看到，通过后台管理，我们可以暂停或者删除任务，以及添加新的任务。当然还有很多其他功能…

OK，关于LTS的简单介绍，以及与SpringBoot的集成，就到这里啦~
希望对看过的小伙伴能有帮助~

凉凉的西瓜
关注
专栏目录
springboot集成dubbo、zookeeper，基于注解形式+源代码+文档说明
11-29
本项目是集成dubbo和zookeeper的一个练习项目，基于注解的配置形式，没有xml文件 ## 环境 #### 操作系统：ubuntu 16.04 LTS #### 开发工具：Idea ## 搭建过程 ### 一、安装zookeeper #### 1、下载zookeeper源码包 >...
LTS 轻量级分布式任务调度框架
最新发布
gitblog_07462的博客
09-13 341
LTS 轻量级分布式任务调度框架 light-task-scheduler Distributed Scheduled Job Framework 项目地址: https://gitcode.com/gh_mirrors/li/l...
LTS分布式任务调度
qq_40313857的博客
08-04 2307
LTS文档 LTS(light-task-scheduler)主要用于解决分布式任务调度问题，支持实时任务，定时任务和Cron任务。有较好的伸缩性，扩展性，健壮稳定性而被多家公司使用，同时也希望开源爱好者一起贡献。 框架概况 LTS 有主要有以下四种节点： JobClient：主要负责提交任务, 并接收任务执行反馈结果。 JobTracker：负责接收并分配任务，任务调度。 TaskTracker：负责执行任务，执行完反馈给JobTracker。 LTS-Admin：（管理后台）主要负责节点管理，任务队列
LTS 分布式任务调度框架教程
gitblog_00225的博客
08-09 958
LTS 分布式任务调度框架教程 light-task-schedulerDistributed Scheduled Job Framework项目地址:https://gitcode.com/gh_mirrors/li/light-task-scheduler 项目介绍 LTS（light-task-scheduler）是一个分布式任务调度框架，主要用于解决分布式环境下的任务调度问题。它支持实时...
软件的Alpha、Beta、GM、OEM、LTS等版本的含义
热门推荐
Hern（宋兆恒）
10-19 6万+
常用版本号： Alpha：软件或系统的内部测试版本，会有很多Bug，仅内部人员使用 Beta：软件或系统的测试版本，这一版本通常是在Alpha版本后，会有很多新功能，同时也有不少Bug Gamma：软件或系统接近于成熟的版本，只需要做一些小的改进就能发行 微软常用的版本号： RC（Release Candidate）：候选版本，这一版本不会增加新功能，多要进行Debug GA（Gene...
LTS 轻量级分布式任务调度框架(Light Task Scheduler)
zhao9tian的专栏
03-08 7811
框架概况：LTS是一个轻量级分布式任务调度框架。有三种角色, JobClient, JobTracker, TaskTracker。各个节点都是无状态的，可以部署多个，来实现负载均衡，实现更大的负载量, 并且框架具有很好的容错能力。 采用多种注册中心（Zookeeper，redis等）进行节点信息暴露，master选举。(Mongo or Mysql)存储任务队列和任务执行日志, netty做底层通
LTS（Light-Task-Scheduler）
CaBCo的博客
07-22 2382
LTS（light-task-scheduler），是一款分布式任务调度框架，支持实时任务、定时任务、Cron任务。
LTS详细使用流程
Wilson的博客
05-22 5950
前言 工作需要使用实时任务，虽然该框架目前属于无人维护的状态，但综合考量下还是使用LTS。编译过程参考LTS框架，不再过多叙述，本文版本v1.7.2。 启动流程 基础环境：这里选用Zookeeper、MongoDB以及MySQL作为前提条件进行启动，具体不展开 按照官方文档编译出dist，备份好原有conf（很重要） 启动lts-admin（含monitor）： 修改conf文件下的l...
springbootdubbo:springboot集成dubbo、zookeeper，基于注解形式
05-18
SpringBoot项目(集成dubbo、zookeeper) 说明 本项目是集成dubbo和zookeeper的一个练习项目，基于注解的配置形式，没有xml文件 环境 操作系统：ubuntu 16.04 LTS 开发工具：Idea 搭建过程 一、安装zookeeper 1、下载...
官方助力:SpringAI快速尝鲜体验(SpringBoot3+Gradle8+JDK17) 项目源码
04-17
Gradle 8可能引入了性能优化，增强了对Java和Kotlin的支持，以及与IDE的更好集成。在SpringAIDemo项目中，Gradle 8将负责编译、打包、测试和部署应用，确保开发流程的顺畅。 接下来，JDK 17是Java开发工具包的最新...
springboot基础讲解
02-28
6. **使用 @SpringBootApplication 注解**：这是 Spring Boot 中的核心注解，集成了 `@SpringBootConfiguration`、`@EnableAutoConfiguration` 和 `@ComponentScan`。 7. **运行应用程序**： - **从 IDE 中运行**...
这是springboot创建项目的初始源码
08-30
4. **MyBatis集成**：集成MyBatis需要在`pom.xml`中添加对应的依赖，并在`application.yml`中配置数据源以及MyBatis的相关配置，例如mapper文件的位置、事务管理器类型等。 5. **Java 11**：项目使用了Java 11作为...
LTS(light-task-scheduler)
一名系统架构师的征途
11-24 4051
LTS用户文档LTS(light-task-scheduler)主要用于解决分布式任务调度问题，支持实时任务，定时任务和Cron任务。有较好的伸缩性，扩展性，健壮稳定性而被多家公司使用，同时也希望开源爱好者一起贡献。项目地址github地址: https://github.com/ltsopensource/light-task-scheduleroschina地址: http://git.osc...
什么是LTS、Alpha、Beta、Dev、Release、Patch版本，软件的开发周期有多少种命名
凌凌1301的博客
04-28 5685
说明：Pre-alpha是指在软件项目进行正式测试之前执行的所有活动。这些活动包括需求分析、软件设计、软件开发和单元测试。在典型的开源开发中，有几种类型的pre-alpha版本。里程碑版本包括特定的功能集，并在功能完成后尽快发布Alpha软件发布生命周期的alpha阶段是软件测试的第一阶段。在此阶段，开发人员通常使用白盒技术测试软件。然后，由另一个测试团队使用黑盒或灰盒技术进行额外的验证。向组织内部转换到黑盒测试称为alpha发布。
【各种**问题系列】什么是 LTS 长期支持
范同学的学习历程
01-26 1907
长期支持（LTS）版本通常与应用程序或操作系统有关，你会在较长的时间内获得安全、维护和（有时有）功能的更新。LTS 版本被认为是最稳定的版本，它经历了广泛的测试，并且大多包含了多年积累的改进。需要注意的是，LTS 版本的软件不一定涉及功能更新，除非有一个更新的 LTS 版本。但是，你会在 LTS 版本的更新中得到必要的错误修复和安全修复。LTS 版本被推荐给生产级的消费者、企业和商家，因为你可以获得多年的软件支持，而且软件更新不会破坏系统。
idea 阿里 建立 springboot 工程 方法 LTS
abc
05-10 811
idea 阿里 建立 springboot 工程 方法 LTS https://start.spring.io/ http://start.aliyun.com
LTS分布式定时调度框架原理
my java博客园
04-26 1498
LTS分布式定时调度框架简单介绍和基本原理
springboot集成LTS
qq_22650813的博客
08-27 633
下载 github地址: https://github.com/ltsopensource/light-task-scheduler oschina地址: http://git.oschina.net/hugui/light-task-scheduler 配置操作环境 ：maven，JDK,MySQL 创建数据库 create database lts; 执行resources\sql\mysql\lts_admin_node_onoffline_log.sql脚本。 运行项目根目录（light-task
5分钟搞定，实现 定时任务 的五种方案！
m0_71777195的博客
12-12 2304
我们在实际开发中，多多少少都会用到定时任务来处理一些问题。比如金融项目中的对账，每天定时对昨天的账务进行核对，每个月初对上个月的账务进行核对等。还比如，我们需要处理一些老数据迁移，修复一些新项目和老项目数据不兼容的问题等等。学习资料的：0 基础 Java 自学之路（配套教程）方案1：Timer这个目前在项目中用得较少，直接贴demo代码。具体的介绍可以查看api ，但是在某些框架中是有用到。 执行结果： 这么使用，阿里代码检查插件会提示：从提示中可以看出，在多线程并行处理定时任务时，Timer运行多
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值