精华内容
下载资源
问答
  • 使用spring task进行Java定时任务开发(超简单)
    本文介绍Spring3.0以后自主开发的定时任务工具,spring task,可以将它比作一个轻量级的Quartz,而且使用起来很简单,除spring相关的包外不需要额外的包,而且支持注解和配置文件两种,这里我们介绍注解的形式
    形式,下面将分别介绍这两种方式。
    第一步:编写作业类
    import org.springframework.stereotype.Service;    
     @Service
    public class TaskJob {    
      public void deleteFrontFile() {    
      	System.out.println(“任务进行中。。。”);    
        }    
    }   

    第二步:在spring配置文件头中添加命名空间及描述
    <beans xmlns="http://www.springframework.org/schema/beans"    
        xmlns:task="http://www.springframework.org/schema/task"     
        xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">

    第三步:spring配置文件中设置具体的任务
    <!-- 定时任务task -->
    	<task:scheduled-tasks>
    		<task:scheduled ref="taskJob" method="deleteFrontFile" cron="0 30 8 * * ?" />
    	</task:scheduled-tasks>
    	<context:component-scan base-package="com.askingdee.htgl.common.task" />

    说明:ref参数指定的即任务类,method指定的即需要运行的方法,cron及cronExpression表达式,具体写法这里不介绍了,详情见上篇文章附录。
    这个配置不需要多说了,spring扫描注解用的。
    到这里配置就完成了,是不是很简单。

    展开全文
  • 本文的主要内容是将java的几个分布式定时任务框架做个对比总结。【框架列举】单机1.timer:是一个定时器类,通过该类可以为指定的定时任务进行配置。TimerTask类是一个定时任务类,该类实现了Runnable接口,缺点异常...

    本文的主要内容是将java的几个分布式定时任务框架做个对比总结。

    【框架列举】

    单机

    1.timer:是一个定时器类,通过该类可以为指定的定时任务进行配置。TimerTask类是一个定时任务类,该类实现了Runnable接口,缺点异常未检查会中止线程

    2.ScheduledExecutorService:相对延迟或者周期作为定时任务调度,缺点没有绝对的日期或者时间

    3.spring定时框架:配置简单功能较多,如果系统使用单机的话可以优先考虑spring定时器

    分布

    1.Quartz:Java事实上的定时任务标准。但Quartz关注点在于定时任务而非数据,并无一套根据数据处理而定制化的流程。虽然Quartz可以基于数据库实现作业的高可用,但缺少分布式并行调度的功能

    2.Spring batch:轻量级的,完全面向Spring的批处理框架,可以应用于企业级大量的数据处理系统。Spring Batch以POJO和Spring框架为基础,使开发者更容易的访问和利用企业级.服务。Spring Batch可以提供大量的,可重复的数据处理功能,包括日志记录/跟踪,事务管理,作业处理统计工作重新启动、跳过,和资源管理等重要功能。

    3.TBSchedule:阿里早期开源的分布式任务调度系统。使用timer而非线程池执行任务调度。众所周知,timer在处理异常状况时是有缺陷的。而且TBSchedule作业类型较为单一,只能是获取/处理数据一种模式。文档缺失比较严重。

    4.elastic-job:当当开发的弹性分布式任务调度系统,功能丰富强大,采用zookeeper实现分布式协调,实现任务高可用以及分片,目前是版本2.15,并且可以支持云开发

    5.xxl-job: 是大众点评员工徐雪里于2015年发布的分布式任务调度平台,是一个轻量级分布式任务调度框架,其核心设计目标是开发迅速、学习简单、轻量级、易扩展。

    【加群】:857565362

    【框架对比】

    下面主要将xxl-job和elastic-job进行简单对比。

    公司

    x-job:个人,大众点评公司员工许雪里,贡献者3人;

    e-job:当当网开源,贡献者17人;

    支持集群部署

    x-job:保证每个集群节点配置(db和登陆账号等)保持一致。调度中心通过db配置区分不同集群。执行器支持集群部署,提升调度系统可用性,同时提升任务处理能力。集群部署唯一要求为:保证集群中每个执行器的配置项 “xxl.job.admin.addresses/调度中心地址” 保持一致,执行器根据该配置进行执行器自动注册等操作。

    e-job:重写Quartz基于数据库的分布式功能,用Zookeeper实现注册中心。作业注册中心: 基于Zookeeper和其客户端Curator实现的全局作业注册控制中心。用于注册,控制和协调分布式作业执行。

    多节点部署时任务不能重复执行

    x-job:使用Quartz基于数据库的分布式功能

    e-job:将任务拆分为n个任务项后,各个服务器分别执行各自分配到的任务项。一旦有新的服务器加入集群,或现有服务器下线,elastic-job将在保留本次任务执行不变的情况下,下次任务开始前触发任务重分片。

    日志

    x-job:支持日志可追溯,有日志查询界面

    e-job:可通过事件订阅的方式处理调度过程的重要事件,用于查询、统计和监控。Elastic-Job目前提供了基于关系型数据库两种事件订阅方式记录事件

    监控报警

    x-job:调度失败时,将会触发失败报警,如发送报警邮件。任务调度失败时邮件通知的邮箱地址,支持配置多邮箱地址,配置多个邮箱地址时用逗号分隔

    e-job:通过事件订阅方式可自行实现

    弹性扩容缩容

    x-job:使用Quartz基于数据库的分布式功能,服务器超出一定数量会给数据库造成一定的压力

    e-job:通过zk实现各服务的注册、控制及协调

    支持并行调度

    x-job:调度系统多线程(默认10个线程)触发调度运行,确保调度精确执行,不被堵塞

    e-job:采用任务分片方式实现。将一个任务拆分为n个独立的任务项,由分布式的服务器并行执行各自分配到的分片项

    高可用策略

    x-job:“调度中心”通过DB锁保证集群分布式调度的一致性, 一次任务调度只会触发一次执行

    e-job:调度器的高可用是通过运行几个指向同一个ZooKeeper集群的Elastic-Job-Cloud-Scheduler实例来实现的。ZooKeeper用于在当前主Elastic-Job-Cloud-Scheduler实例失败的情况下执行领导者选举。通过至少两个调度器实例来构成集群,集群中只有一个调度器实例提供服务,其他实例处于”待命”状态。当该实例失败时,集群会选举剩余实例中的一个来继续提供服务

    失败处理策略

    x-job:调度失败时的处理策略,策略包括:失败告警(默认)、失败重试

    e-job:弹性扩容缩容在下次作业运行前重分片,但本次作业执行的过程中,下线的服务器所分配的作业将不会重新被分配。失效转移功能可以在本次作业运行中用空闲服务器抓取孤儿作业分片执行。同样失效转移功能也会牺牲部分性能

    【对比总结】

    共同点

    x-Job和e-job都有广泛的用户基础和完整的技术文档,都能满足定时任务的基本功能需求。

    不同点

    x-Job 侧重的业务实现的简单和管理的方便,学习成本简单,失败策略和路由策略丰富。推荐使用在“用户基数相对少,服务器数量在一定范围内”的情景下使用

    e-Job 关注的是数据,增加了弹性扩容和数据分片的思路,以便于更大限度的利用分布式服务器的资源。但是学习成本相对高些,推荐在“数据量庞大,且部署服务器数量较多”时使用

    【学习总结】

    考虑公司项目进度,优先选择了学习成本较低的x-job,对比总结是学习x-job的一个基石,有了宏观认识,才能更好地深入。

    我这儿整理了比较全面的JAVA相关的面试资料,

    需要领取面试资料的同学,请加群:473984645

    0dbec548e55a577abcf1ca88516d467b.png

    获取更多学习资料,可以加群:473984645或扫描下方二维码

    be247fda115e24b76054e52abe3f4493.png
    展开全文
  • java定时任务

    千次阅读 2020-07-07 14:29:49
    @[TOC]java定时任务 Java定时任务 Java开发过程中经常会遇到使用定时任务的情况,我总结了一下有如下四种方式:Timer、ScheduledExecutorService、SpringTask、Quartz。 一、使用java的Timer 1、Timer new Timer(...

    @[TOC]java定时任务

    Java定时任务

    Java开发过程中经常会遇到使用定时任务的情况,我总结了一下有如下四种方式:Timer、ScheduledExecutorService、SpringTask、Quartz。

    一、使用java的Timer
    1、Timer

    new Timer("testTimer").schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("TimerTask");
                }
            }, 1000,2000);
    

    解释:1000ms是延迟启动时间,2000ms是定时任务周期,每2s执行一次

    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    try {
    	Date date = dateFormat.parse("2018-07-11 12:00:00.000");
    	new Timer("testTimer1").scheduleAtFixedRate(new TimerTask() {
    		@Override
    		public void run() {
    			System.out.println("TimerTask");
    		}
    	}, date,2000);
    } catch (ParseException e) {
    	e.printStackTrace();
    }
    

    解释:date是开始时间,2000ms是定时任务周期,每2s执行一次
    timer有2中方法schedule和scheduleAtFixedRate,前者会等任务结束在开始计算时间间隔,后者是在任务开始就计算时间,有并发的情况

    二、使用ScheduledExecutorService
    1、ScheduledExecutorService

    scheduledExecutorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("ScheduledTask");
                }
            },1, TimeUnit.SECONDS);
    

    解释:延迟1s启动,执行一次

    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
            scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println("ScheduledTask");
                }
            }, 1, 1, TimeUnit.SECONDS);
    

    解释:延迟1s启动,每隔1s执行一次,是前一个任务开始时就开始计算时间间隔,但是会等上一个任务结束在开始下一个

    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
            scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    System.out.println("ScheduledTask");
                }
            }, 1, 1, TimeUnit.SECONDS);
    

    解释:延迟1s启动,在前一个任务执行完成之后,延迟1s在执行

    三、使用SpringTask
    1、写任务类

    package com.zb.timedtask;
    import com.zb.controller.StudentController;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Service;
    
    @Service
    public class SpringTask {
        private static final Logger log = LoggerFactory.getLogger(SpringTask.class);
    
        @Scheduled(cron = "1/5 * * * * *")
        public void task1(){
            log.info("springtask 定时任务!");
        }
    	
    	@Scheduled(initialDelay = 1000,fixedRate = 1*1000)
        public void task2(){
            log.info("springtask 定时任务!");
        }
    }
    

    解释:
    task1是每隔5s执行一次,{秒} {分} {时} {日期} {月} {星期}
    task2是延迟1s,每隔1S执行一次

    2、配置文件修改
    (1)简单版

    <task:annotation-driven/>
    

    (2)任务池版

    <task:executor id="executor" pool-size="10" />
    <task:scheduler id="scheduler" pool-size="10" />
    <task:annotation-driven executor="executor" scheduler="scheduler" />
    

    (3)解释
    假如只有一个定时任务,可以用简单版;如果有多个定时任务,则要用任务池,不然它会顺序执行。

    两个任务的时间间隔为:执行时间+设定的定时间隔

    例子:(这个任务8s执行一次)

    @Scheduled(cron = "1/4 * * * * *")
    public void task2(){
    	log.info("springtask 定时任务2!");
    	try {
    		TimeUnit.SECONDS.sleep(4);
    	} catch (InterruptedException e) {
    		e.printStackTrace();
    	}
    }
    

    四、使用Quartz框架
    1、加依赖

    <!-- quartz -->
    <dependency>
      <groupId>org.quartz-scheduler</groupId>
      <artifactId>quartz</artifactId>
      <version>2.3.0</version>
    </dependency>
    <!--调度器核心包-->
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-context-support</artifactId>
    	<version>4.3.4.RELEASE</version>
    </dependency>
    

    2、Job实现

    package com.zb.quartz;
    
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class HelloWorldJob implements Job {
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());
            System.out.println( strTime + ":Hello World!");
        }
    }
    

    3、调度器(可以用listener在项目启动时执行)

    import org.quartz.*;
    import org.quartz.impl.StdSchedulerFactory;
    
    public class MyScheduler {
        public static void main(String[] args) throws SchedulerException {
            //创建调度器Schedule
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();
            Scheduler scheduler = schedulerFactory.getScheduler();
            //创建JobDetail实例,并与HelloWordlJob类绑定
            JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).withIdentity("job1", "jobGroup1")
                    .build();
            //创建触发器Trigger实例(立即执行,每隔1S执行一次)
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity("trigger1", "triggerGroup1")
                    .startNow()
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())
                    .build();
            //开始执行
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();
        }
    }
    

    解释:上面用的是简单触发器,也可以用Con触发器,如下

    Trigger cronTrigger = TriggerBuilder.newTrigger()
                    .withIdentity("trigger2", "triggerGroup2")
                    .startNow()
                    .withSchedule(cronSchedule("0 42 10 * * ?"))
                    .build();
    

    4、整合spring
    也可以直接把上面的调度器写成配置文件,整合spring

    (1)job

    package com.zb.quartz;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class QuarFirstJob {
        public void first() {
            String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());
            System.out.println( strTime + ":Hello World!");
        }
    }
    

    (2)配置文件

    <bean id="QuarFirstJob" class="com.zb.quartz.QuarFirstJob" />
    
    <bean id="jobDetail"
    	  class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    	<property name="group" value="quartzGroup1" />
    	<property name="name" value="quartzJob1" />
    	<!--false表示等上一个任务执行完后再开启新的任务 -->
    	<property name="concurrent" value="false" />
    	<property name="targetObject">
    		<ref bean="QuarFirstJob" />
    	</property>
    	<property name="targetMethod">
    		<value>first</value>
    	</property>
    </bean>
    
    <!-- 调度触发器 -->
    <bean id="myTrigger"
    	  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    	<property name="name" value="trigger1" />
    	<property name="group" value="group1" />
    	<property name="jobDetail">
    		<ref bean="jobDetail" />
    	</property>
    	<property name="cronExpression">
    		<value>0/5 * * * * ?</value>
    	</property>
    </bean>
    
    <!-- 调度工厂 -->
    <bean id="scheduler"
    	  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    	<property name="triggers">
    		<list>
    			<ref bean="myTrigger" />
    		</list>
    	</property>
    </bean>
    

    5、时间

    public class QuarFirstJob {
        public void first() {
            try {
                TimeUnit.SECONDS.sleep(6);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());
            System.out.println( strTime + ":Hello World!");
        }
    }
    

    上面的配置里面写是5s间隔,把上面的sleep时间分别改成4和6,发现两次任务间隔是执行时间和间隔时间的最大值,分别是5,6

    总结
    Quartz是执行时间和间隔时间的最大值(比如;执行时间是3s,间隔是2s,则每3s执行一次;执行时间是3s,间隔是5s,则每5s执行一次。)
    Spring task是执行时间+间隔时间(比如;执行时间是3s,间隔是2s,则每5s执行一次;执行时间是3s,间隔是5s,则每8s执行一次。)
    timer有2中方法schedule和scheduleAtFixedRate,前者会等任务结束在开始计算时间间隔,后者是在任务开始就计算时间,有并发的情况
    ScheduledExecutorService的scheduleAtFixedRate类似Quartz,scheduleWithFixedDelay类似SpringTaskJava定时任务
    Java开发过程中经常会遇到使用定时任务的情况,我总结了一下有如下四种方式:Timer、ScheduledExecutorService、SpringTask、Quartz。

    展开全文
  • java定时_Java定时任务

    2021-02-12 08:55:06
    Java开发过程中经常会遇到使用定时任务的情况,我总结了一下有如下四种方式:Timer、ScheduledExecutorService、SpringTask、Quartz。一、使用java的Timer1、Timernew Timer("testTimer").schedule(new TimerTask() ...

    Java开发过程中经常会遇到使用定时任务的情况,我总结了一下有如下四种方式:Timer、ScheduledExecutorService、SpringTask、Quartz。

    一、使用java的Timer

    1、Timer

    new Timer("testTimer").schedule(new TimerTask() {

    @Override

    public void run() {

    System.out.println("TimerTask");

    }

    }, 1000,2000);

    解释:1000ms是延迟启动时间,2000ms是定时任务周期,每2s执行一次

    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

    try {

    Date date = dateFormat.parse("2018-07-11 12:00:00.000");

    new Timer("testTimer1").scheduleAtFixedRate(new TimerTask() {

    @Override

    public void run() {

    System.out.println("TimerTask");

    }

    }, date,2000);

    } catch (ParseException e) {

    e.printStackTrace();

    }

    解释:date是开始时间,2000ms是定时任务周期,每2s执行一次

    timer有2中方法schedule和scheduleAtFixedRate,前者会等任务结束在开始计算时间间隔,后者是在任务开始就计算时间,有并发的情况

    二、使用ScheduledExecutorService

    1、ScheduledExecutorService

    scheduledExecutorService.schedule(new Runnable() {

    @Override

    public void run() {

    System.out.println("ScheduledTask");

    }

    },1, TimeUnit.SECONDS);

    解释:延迟1s启动,执行一次

    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

    scheduledExecutorService.scheduleAtFixedRate(new Runnable() {

    @Override

    public void run() {

    System.out.println("ScheduledTask");

    }

    }, 1, 1, TimeUnit.SECONDS);

    解释:延迟1s启动,每隔1s执行一次,是前一个任务开始时就开始计算时间间隔,但是会等上一个任务结束在开始下一个

    ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);

    scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {

    @Override

    public void run() {

    System.out.println("ScheduledTask");

    }

    }, 1, 1, TimeUnit.SECONDS);

    解释:延迟1s启动,在前一个任务执行完成之后,延迟1s在执行

    三、使用SpringTask

    1、写任务类

    package com.zb.timedtask;

    import com.zb.controller.StudentController;

    import org.slf4j.Logger;

    import org.slf4j.LoggerFactory;

    import org.springframework.scheduling.annotation.Scheduled;

    import org.springframework.stereotype.Service;

    @Service

    public class SpringTask {

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

    @Scheduled(cron = "1/5 * * * * *")

    public void task1(){

    log.info("springtask 定时任务!");

    }

    @Scheduled(initialDelay = 1000,fixedRate = 1*1000)

    public void task2(){

    log.info("springtask 定时任务!");

    }

    }

    解释:

    task1是每隔5s执行一次,{秒} {分} {时} {日期} {月} {星期}

    task2是延迟1s,每隔1S执行一次

    2、配置文件修改

    (1)简单版

    (2)任务池版

    (3)解释

    假如只有一个定时任务,可以用简单版;如果有多个定时任务,则要用任务池,不然它会顺序执行。

    两个任务的时间间隔为:执行时间+设定的定时间隔

    例子:(这个任务8s执行一次)

    @Scheduled(cron = "1/4 * * * * *")

    public void task2(){

    log.info("springtask 定时任务2!");

    try {

    TimeUnit.SECONDS.sleep(4);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    四、使用Quartz框架

    1、加依赖

    org.quartz-scheduler

    quartz

    2.3.0

    org.springframework

    spring-context-support

    4.3.4.RELEASE

    2、Job实现

    package com.zb.quartz;

    import org.quartz.Job;

    import org.quartz.JobExecutionContext;

    import org.quartz.JobExecutionException;

    import java.text.SimpleDateFormat;

    import java.util.Date;

    public class HelloWorldJob implements Job {

    @Override

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

    String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());

    System.out.println( strTime + ":Hello World!");

    }

    }

    3、调度器(可以用listener在项目启动时执行)

    import org.quartz.*;

    import org.quartz.impl.StdSchedulerFactory;

    public class MyScheduler {

    public static void main(String[] args) throws SchedulerException {

    //创建调度器Schedule

    SchedulerFactory schedulerFactory = new StdSchedulerFactory();

    Scheduler scheduler = schedulerFactory.getScheduler();

    //创建JobDetail实例,并与HelloWordlJob类绑定

    JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).withIdentity("job1", "jobGroup1")

    .build();

    //创建触发器Trigger实例(立即执行,每隔1S执行一次)

    Trigger trigger = TriggerBuilder.newTrigger()

    .withIdentity("trigger1", "triggerGroup1")

    .startNow()

    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())

    .build();

    //开始执行

    scheduler.scheduleJob(jobDetail, trigger);

    scheduler.start();

    }

    }

    解释:上面用的是简单触发器,也可以用Con触发器,如下

    Trigger cronTrigger = TriggerBuilder.newTrigger()

    .withIdentity("trigger2", "triggerGroup2")

    .startNow()

    .withSchedule(cronSchedule("0 42 10 * * ?"))

    .build();

    4、整合spring

    也可以直接把上面的调度器写成配置文件,整合spring

    (1)job

    package com.zb.quartz;

    import java.text.SimpleDateFormat;

    import java.util.Date;

    public class QuarFirstJob {

    public void first() {

    String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());

    System.out.println( strTime + ":Hello World!");

    }

    }

    (2)配置文件

    class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

    first

    class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">

    0/5 * * * * ?

    class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

    5、时间

    public class QuarFirstJob {

    public void first() {

    try {

    TimeUnit.SECONDS.sleep(6);

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());

    System.out.println( strTime + ":Hello World!");

    }

    }

    上面的配置里面写是5s间隔,把上面的sleep时间分别改成4和6,发现两次任务间隔是执行时间和间隔时间的最大值,分别是5,6

    总结

    Quartz是执行时间和间隔时间的最大值(比如;执行时间是3s,间隔是2s,则每3s执行一次;执行时间是3s,间隔是5s,则每5s执行一次。)

    Spring task是执行时间+间隔时间(比如;执行时间是3s,间隔是2s,则每5s执行一次;执行时间是3s,间隔是5s,则每8s执行一次。)

    timer有2中方法schedule和scheduleAtFixedRate,前者会等任务结束在开始计算时间间隔,后者是在任务开始就计算时间,有并发的情况

    ScheduledExecutorService的scheduleAtFixedRate类似Quartz,scheduleWithFixedDelay类似SpringTask

    展开全文
  • 在web开发中我们经常需要定时完成一些功能比如定义统计报表啊统计用户排名等等利用spring就可以轻松地做到这些任务下面我就以定时发送邮件来来展示如何利用spring定时发送邮件以及spring对JavaMail的简化 ...
  • 如下图所示,创建真正的任务调度。核心代码:executor.scheduleAtFixedRate( )。为什么用scheduleAtFixedRate呢?scheduleAtFixedRate(TimerTasktask, longdelay,longperiod) 安排指定的任务在指定的延迟后开始进行...
  • Java定时任务

    2018-07-11 15:24:00
    Java定时任务 Java开发过程中经常会遇到使用定时任务的情况,我总结了一下有如下四种方式:Timer、ScheduledExecutorService、SpringTask、Quartz。 一、使用java的Timer 1、Timer new Timer(...
  • java 定时任务

    2017-09-12 14:24:21
    基于springboot+mybatis实现的一个定时任务项目, 直接可以使用,里面有例子,mvc分层,可以进行二次开发
  • Java项目部署到Linux并配置定时任务1、在Eclipse中将程序开发好,并进行编译成.class文件2、在linux中创建对应的目录,本人在linux中创建StatShareDataProject 目录用来存放程序,同时在这个目录下创建如下所示的...
  • 前言在实际项目开发中,除了Web应用、SOA服务外,还有一类不可缺少的,那就是定时任务调度。定时任务的场景可以说非常广泛,比如某些视频网站,购买会员后,每天会给会员送成长值,每月会给会员送一些电影券;比如在...
  • JAVA实现定时任务的几种方式@(JAVA)[spring|quartz|定时器]近期项目开发中需要动态的添加定时任务,比如在某个活动结束时,自动生成获奖名单,导出excel等,此类任务由于活动时间是动态的,不能把定时任务配置在配置...
  • 前言在实际项目开发中,除了Web应用、SOA服务外,还有一类不可缺少的,那就是定时任务调度。定时任务的场景可以说非常广泛,比如某些视频网站,购买会员后,每天会给会员送成长值,每月会给会员送一些电影券;比如在...
  • System.out.println("定时任务1"); } @Scheduled(initialDelay = 1000 * 10,fixedRate = 1000 * 3) public void scheduledTask2(){ System.out.println("任务2执行时间:"+System.currentTimeMillis()); ...
  • 定时任务执行时间配置详解Seconds Minutes Hours Day-of-month Month Day-of-Week Year秒分 时 天 月 周 年Seconds 0-59 , - * /Minutes 0-59 , - ...
  • 现代的 Web 应用程序框架在范围和复杂性...目前 Java 系统中实现调度任务的方式大体有一下三种:Java 实现调度任务的三种方式一、使用JDK自带的java.util.Timer及java.util.TimerTask类实现在我们编程过程中如果需...
  • 开发测试工具的应用后台,经常听到同事说要做个定时任务把做日志处理,或者数据清理,包括做些复杂的业务计算逻辑,在选择定时任务的时候,怎么能够快速实现,并且选择一种更适合自己的方式呢? 我这里把定时任务...
  • 详解java定时任务

    2017-09-22 09:23:51
    CSDN首页学院下载更多 论坛 问答 活动 码云 商城 下载 CSDN APP写博客登录|注册 Java_2017_csdn ...首页移动开发架构云计算/大数据互联网运维数据库前端编程语言研发管理综合 ...详解java定时任务
  • java定时任务实现的几种方式

    万次阅读 多人点赞 2017-10-13 09:58:48
    摘要: 在开发测试工具的应用后台,经常听到同事说要做个定时任务把做日志处理,或者数据清理,包括做些复杂的业务计算逻辑,在选择定时任务的时候,怎么能够快速实现,并且选择一种更适合自己的方式呢?我这里把...
  • Java定时任务调度工具

    2018-01-21 11:18:54
    title: Java定时任务调度工具 为什么要使用定时任务调度工具? 在最近的开发中,想开发一个“个人备忘录”的功能,实际上就是用户在指定某个时间点后,就在那个时间点发送邮件提醒用户去做xxx事。 既然是这样的一个...
  • 主要介绍了java定时任务框架elasticjob详解,Elastic-Job是ddframe中dd-job的作业模块中分离出来的分布式弹性作业框架。该项目基于成熟的开源产品Quartz和Zookeeper及其客户端Curator进行二次开发。,需要的朋友可以...
  • 定时任务在主流开发语言均提供相应的API供开发者调用,在Java中,实现定时任务有很多种方式,原生的方式实现一个完整定时任务需要由Timer、TimerTask两个类,Timer是定时器类,用来按计划开启后台线程执行指定任务,...
  • Java定时任务调度

    2018-03-30 14:54:18
    在实际开发中,会经常定时更新一些数据,小到Java项目中的collection,大到数据库表格。又比如定时给客户发送email;又比如说交易所行情数据每天存储完成后,需要根据历史数据进行筛选新的开仓数据作为条件定时存储...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,775
精华内容 710
关键字:

java定时任务开发

java 订阅