思享工具箱

Java定时任务

摘要：
");}}解释：task1是每隔5s执行一次，{秒}{分}{时}{日期}{月}{星期}task2是延迟1s,每隔1S执行一次2、配置文件修改简单版任务池版解释假如只有一个定时任务，可以用简单版；如果有多个定时任务，则要用任务池，不然它会顺序执行。两个任务的时间间隔为：执行时间+设定的定时间隔例子：@Scheduledpublicvoidtask2(){log.info("springtask定时任务2！");try{TimeUnit.SECONDS.sleep;}catch{e.printStackTrace();}}四、使用Quartz框架1、加依赖˂!

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   pool-size="10" />
<task: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     />

<bean  
	  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  
	  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  
	  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类似SpringTask

浏览：414 | 发布日期：

免责声明：文章转载自《Java定时任务》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇三款优秀的替代Xshell的SSH软件js批量下载文件下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

随便看看

django的优缺点（非原创）

Django做了很多。使用它快速开发一些Web应用程序是很好的。因此，在一些人眼中，Django只不过是一种灵丹妙药，但对一些人来说，它也是一种毒药和剧毒。Django开发人员也讨论并试图支持SQLAlchemy，但最终放弃了。据估计，成本太高，很难与Django的其他模块集成。尽管Django的ORM不如SQLAlchemy强大，但它并不弱。Django的...

PHP是怎么运行的

严格来说，与PHP相关的过程不需要手动启动。它们与Apache启动一起运行。当然，如果需要重新启动PHP服务，可以手动重新启动PHP。最后，它被移交给PHP内核的ZendEngine进行顺序执行。PHP在开始执行后将经历两个主要阶段：处理请求之前的开始阶段和请求之后的结束阶段。PHP的结束阶段分为两个阶段：禁用模块和关闭模块。...

wxparse使用（富文本插件）

优点：唯一已知的可以将HTML转换为小程序识别的插件缺点：转换HTML标签可能需要大量的微信小程序标签和样式配置：步骤1，下载https://github.com/icindy/wxParse第二步：把它放到项目中。我选择页面目录。步骤3：配置wxml以添加：需要时使用：...

fiddler抓包+雷电模拟器 完成手机app抓包的配置

找到系统应用，点击设置，点击无线网络WLAN—˃左键常按点击已连接网络—˃修改网络鼠标左键长按在桌面找到下面这个文件之后双击打开上面证书弄完之后。可以说本机已经安装过证书了，如果你能在模拟器上找到这个证书就不用将这个证书再拉入模拟器了在模拟器中打开系统应用—˃设置—˃安全—˃从SD卡安装。找到FiddlerRoot.cer文件，按提示导入即可，注意在此过程需...

Nginx 对客户端请求的限制

本文记录了Nginx静态web服务器对客户端请求的限制的配置项。附加了禁止GET方法和HEAD方法的配置。limit_ exceptGET｛allow192.168.1.0/32；denyall；｝2） 最大HTTP请求包语法：client_max_body_sizesize；默认值：client_max_body_size1m；配置块：当http、服务器和...

推荐几种加快火狐浏览器速度的办法

键入browser.cache。内存容量，指定值65536。确认后，重新启动Firefox以获得更大的缓存。这对于减少数据传输非常有帮助，特别是如果您的月流量有限，并且它几乎可以使Firefox浏览器的性能翻倍。...

最新文章

随机推荐

思享工具箱导航