Java之旅--定时任务(Timer、Quartz、Spring、LinuxCron)

在Java中，实现定时任务有多种方式。本文介绍4种。Timer和TimerTask、Spring、QuartZ、Linux Cron。

以上4种实现定时任务的方式。Timer是最简单的。不须要不论什么框架，只JDK就能够。缺点是不过个时间间隔的定时器，调度简单。Spring和QuartZ都支持cron，功能都非常强大，Spring的长处是略微简单一点，QuartZ的长处是没有Spring也可使用；Linux Cron是个操作系统级别的定时任务。适用于全部操作系统支持的语言，缺点是精度只能到达分钟级别。

Timer和TimerTask

关于Timer定时器的实现原理，假设我们看过JDK源代码，就会发现，是使用的Object.wait(timeout)。来进行的线程堵塞，timeout是依据下次运行实际和当前实际之差来计算。实际上，这能够归结为一个多线程协作（协作都是在相互排斥下的协作）问题。

在java.util.concurrent中。有个ScheduledThreadPoolExecutor。也能够全然实现定时任务的功能。

而其它的框架，无非是功能的增强，特性很多其它，更好用，都是在基础的java之上的包装。

代码示比例如以下：

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
public class TimerTest extends TimerTask
{
    private Timer timer;
    public static void main(String[] args)
    {
        TimerTest timerTest= new TimerTest();
        timerTest.timer = new Timer();
        //立马開始运行timerTest任务，仅仅运行一次
        timerTest.timer.schedule(timerTest,new Date());
        //立马開始运行timerTest任务，运行完本次任务后。隔2秒再运行一次
        //timerTest.timer.schedule(timerTest,new Date(),2000);
        //一秒钟后開始运行timerTest任务。仅仅运行一次
        //timerTest.timer.schedule(timerTest,1000);
        //一秒钟后開始运行timerTest任务，运行完本次任务后，隔2秒再运行一次
        //timerTest.timer.schedule(timerTest,1000,2000);
        //立马開始运行timerTest任务，每隔2秒运行一次
        //timerTest.timer.scheduleAtFixedRate(timerTest,new Date(),2000);
        //一秒钟后開始运行timerTest任务。每隔2秒运行一次
        //timerTest.timer.scheduleAtFixedRate(timerTest,1000,2000);  

        try
        {
            Thread.sleep(10000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        //结束任务运行，程序终止
        timerTest.timer.cancel();
        //结束任务运行。程序并不终止,由于线程是JVM级别的
        //timerTest.cancel();
    }
    @Override
    public void run()
    {
        System.out.println("Task is running!");
    }
}

使用spring @Scheduled注解运行定时任务

这样的方式很easy，却能使用cron完毕和QuartZ一样的功能，值得推荐一下。

ApplicationContext.xml：

beans根节点添加内容：xmlns:task="http://www.springframework.org/schema/task"

beans根节点中，xsi:schemaLocation属性下添加:

http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.1.xsd

<!-- 开启注解任务 -->

<task:annotation-driven/>

实现类：

@Component  //import org.springframework.stereotype.Component;
public class MyTestServiceImpl  implements IMyTestService {
      @Scheduled(cron="0/5 * *  * * ? ")   //每5秒运行一次
      @Override
      public void myTest(){
            System.out.println("进入測试");
      }
}

注意几点：

spring的@Scheduled注解  须要写在实现上；

定时器的任务方法不能有返回值；

实现类上要有组件的注解@Component。@Service。@Repository

QuartZ

QuartZ With Spring

applicationContext-schedule.xml

<?

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
 <bean id="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
  <property name="triggers">
   <list>
    <!-- 启动的Trigger列表 -->
    <ref local="startThriftTrigger" />
   </list>
  </property>
  <property name="quartzProperties">
   <props>
    <prop key="org.quartz.threadPool.threadCount">5</prop>
   </props>
  </property>
  <!-- 启动时延期3秒開始任务 -->
  <property name="startupDelay" value="3" />
  <property name="autoStartup" value="${scheduler.autoStartup}" />
 </bean>

 <!-- 启动Thrift，马上启动 -->
 <bean id="startThriftTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
  <property name="startDelay" value="0" />
        <property name="repeatInterval" value="1000" />
        <property name="repeatCount" value="0" />
        <property name="jobDetail" ref="startThriftTask" />
 </bean>
 <bean id="startThriftTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
  <property name="targetObject" ref="startThrift" />
  <property name="targetMethod" value="execute" />
  <!-- 同一任务在前一次运行未完毕而Trigger时间又到时是否并发開始新的运行, 默觉得true. -->
  <property name="concurrent" value="true" />
 </bean>
</beans>

实现类

package xx.schedule;

@Component
public class StartThrift {
 /**
  * 调度入口
  */
 public void execute() {
  // to do something
 }
}

QuartZ No Spring

使用的QuartZ jar是1.8.5，例如以下：

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>1.8.5</version>
</dependency>

调用类实现代码例如以下：

import org.quartz.CronExpression;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;

public class InvokeStatSchedule {
    public void start() throws SchedulerException
    {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();

        //InvokeStatJob是实现了org.quartz.Job的类
        JobDetail jobDetail = new JobDetail("jobDetail", "jobDetailGroup", InvokeStatJob.class);
        CronTrigger cronTrigger = new CronTrigger("cronTrigger", "triggerGroup");
        try {
            CronExpression cexp = new CronExpression("0 0 * * * ?

");
            cronTrigger.setCronExpression(cexp);
        } catch (Exception e) {
            e.printStackTrace();
        }
        scheduler.scheduleJob(jobDetail, cronTrigger);
        scheduler.start();
    }
}

定时任务类代码例如以下：

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class InvokeStatJob implements Job {

    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        //...要定时操作的内容
    }
}

Linux Cron

这事实上也是一种很普遍的实现定时任务的方式。实际是操作系统的定时任务。Linux Cron仅仅能到达分钟级，到不了秒级别。

一般我们是设置定时运行一个sh脚本，在脚本里面写一些控制代码。比如，有例如以下的脚本：

3,33 * * * * /usr/local/log_parser/run_log_parser.sh &

run_log_parser.sh的内容大致例如以下：

#!/bin/sh

log_parser_dir=/usr/local/log_parser
tmp_file=/usr/local/run_parser_tmp.txt
parser_log=/usr/local/access_parser.log
tmpDir=/data/applogs/access_logs_bp

date >> "$parser_log"

if [! -f "$tmp_file"]; then
        echo ‘訪问日志解析正在进行,尚未完毕‘ >> "$parser_log"
        echo ‘‘ >> "$parser_log"
else
        echo ‘開始解析訪问日志‘ >> "$parser_log"
        touch "$tmp_file"
        cd "$log_parser_dir"
        python access_log_parser.py >> "$parser_log"
        rm "$tmp_file"
        echo ‘解析訪问日志完毕‘ >> "$parser_log"
        echo ‘‘ >> "$parser_log"
        cd "$tmpDir"
        gzip gzip WEB0*
        mv *.gz gz/
        echo ‘压缩备份日志及移动到压缩文件夹成功‘ >> "$parser_log"
fi
时间： 2024-10-20 14:57:37

Java之旅--定时任务(Timer、Quartz、Spring、LinuxCron)的相关文章

SpringBoot之旅 -- 定时任务两种(Spring Schedule 与 Quartz 整合 )实现

相关文章 Spring Boot 相关文章目录 前言 最近在项目中使用到定时任务,之前一直都是使用Quartz 来实现,最近看Spring 基础发现其实Spring 提供 Spring Schedule 可以帮助我们实现简单的定时任务功能.下面说一下两种方式在Spring Boot 项目中的使用. Spring Schedule 实现定时任务 Spring Schedule 实现定时任务有两种方式 1. 使用XML配置定时任务, 2. 使用 @Scheduled 注解. 因为是Spring Bo

atititt.java定时任务框架选型Spring Quartz 注解总结

atititt.java定时任务框架选型Spring Quartz 总结 1. .Spring Quartz  (ati recomm) 1 2. Spring Quartz具体配置 2 2.1. 增加context,task命名空间xml: 2 2.2. 增加xsi:schemaLocation valide 2 2.3. 我们的task任务扫描注解in spr.xml 2 2.4. 设置运行方法 3 2.5. 设置输出日志 3 3. 运行测试sprX走ok兰. 4 4. Quartz Sch

搭建第一个web项目：quartz+spring实现定时任务

测试过程: 先写了一个简单的任务类,测试配置的quartz是否启作用(最终目的是实现定时删除临时储存文件夹). spring中添加的配置文件如下: <!--定时任务 quartz (spring内部集成) --> <!-- 定时清空临时文件夹的任务类 --> <bean id="taskJob" class="cn.itcast.oa.util.TaskJob"></bean> <!-- 定义目标bean和bea

spring定时任务之quartz

在Spring中,使用JDK的Timer类库来做任务调度功能不是很方便,关键它不可以象cron服务那样可以指定具体年.月.日.时和分的时间.你只能将时间通过换算成微秒后传给它.如任务是每天执行一次,则需要在spring中如下配置: ­ <bean id="scheduledTask" class= "org.springframework.scheduling.timer.ScheduledTimerTask"> <!--程序启动后开始执行任务的延

spring定时任务包Quartz版本不兼容

使用spring定时任务包Quartz时,必须使用Quartz1.85以下版本的.     查看发现spring3.0.5中org.springframework.scheduling.quartz.CronTriggerBean继承了     org.quartz.CronTrigger(public class CronTriggerBeanextends CronTrigger),     而在quartz2.1.3中org.quartz.CronTrigger是个接口(publicabs

Java基础--定时任务Timer

Java基础--定时任务Timer 一.Timer介绍 java.util.Timer java.util.TimerTask Timer是一个定时器类,通过该类可以为指定的定时任务进行配置.TimerTask类是一个定时任务类,该类实现了Runnable接口,而且是一个抽象类,如下所示: public abstract class TimerTask implements Runnable 可以通过继承该类,来实现自己的定时任务. Timer定时器实例有多种构造方法: Timer() 创建一个

【59】Quartz+Spring框架详解

什么是Quartz Quartz是一个作业调度系统(a job scheduling system),Quartz不但可以集成到其他的软件系统中,而且也可以独立运行的:在本文中"job scheduler"的意思是:一个负责在约定的时间到达时执行(或通知)其他软件控件的方法. Quartz是非常灵活的,为了实现我们的需求Quartz包含了许多可以独立或被集成使用的典型范例,同时使我们编写项目中的代码也觉得很简单自然(natural). Quartz是很轻量级的,只需要简单的安装或配置就

java之定时器任务Timer用法

在项目开发中,经常会遇到需要实现一些定时操作的任务,写过很多遍了,然而每次写的时候,总是会对一些细节有所遗忘,后来想想可能是没有总结的缘故,所以今天小编就打算总结一下可能会被遗忘的小点: 1. public void schedule(TimerTask task,Date time) 这个方法中如启动时,已经过了time的时间,则系统会在启动后直接执行一次, 话不多少直接上代码 package com.test.timer.task; import java.text.DateFormat;

转：java中的定时任务

引自:http://www.cnblogs.com/wenbronk/p/6433178.html java中的定时任务, 使用java实现有3种方式: 1, 使用普通thread实现 @Test public void test1() { // 单位: 毫秒 final long timeInterval = 1000; Runnable runnable = new Runnable() { public void run() { while (true) { // ------- code