java quartz 定时器

       大家好，今天我将为大家讲解java quartz 定时器的问题。为了让大家更好地理解这个问题，我将相关资料进行了整理，现在就让我们一起来看看吧。

1.java中tomcat挂了后quartz定时任务是否还能运行

2.Timer和spring的Quartz两种定时器的区别

3.java中quartz定时任务的执行如何避免并发

4.Java中定时任务quartz如何将历史数据写入新表

5.java定时方法执行力7-9个小时(quartz框架的定时方法),没有报错(日志没有错误)，却没有把方法执行完

6.quartz定时任务最小时间是多少

java中tomcat挂了后quartz定时任务是否还能运行

       当tomcat挂了之后，quartz任务将停止，因为他没有服务器跑了。

       但是，当你再次启动tomcat，quartz会自动找到已经到点，需要要启动的任务，然后开始运行这个任务。

Timer和spring的Quartz两种定时器的区别

       - JDK自带 ：JDK自带的Timer以及JDK1.5+ 新增的ScheduledExecutorService；?

       - Quartz ：简单却强大的JAVA作业调度框架?

       - Spring3.0以后自带的task ：可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多；

       代码参考：

       JDK 自带的定时器实现

       schedule(TimerTask task, Date time) 特定时间执行

       public static void main(String[] args) {

       for (int i = 0; i < 10; ++i) {

       new Timer("timer - " + i).schedule(new TimerTask() {

       @Override

       public void run() {

       println(Thread.currentThread().getName() + " run ");

       }

       }, new Date(System.currentTimeMillis() + 2000));

       }

       }

       Quartz 定时器实现

       2.1? 通过maven引入依赖（这里主要介绍2.3.0） ?注意：shiro-scheduler中依赖的是1.x版本 ?如果同时使用会冲突

       <!-- /artifact/org.quartz-scheduler/quartz -->

       <dependency>

       <groupId>org.quartz-scheduler</groupId>

       <artifactId>quartz</artifactId>

       <version>2.3.0</version>

       </dependency>

       2.2?创建Job类

       public class TestJob implements Job{

       @Override

       public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

       println(Thread.currentThread().getName() + " test job begin " + DateUtil.getCurrentTimeStr());

       }

       }

       2.3?调度任务

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

       Scheduler scheduler = new StdSchedulerFactory().getScheduler();

       // 开始

       scheduler.start();

       // job 唯一标识 test.test-1

       JobKey jobKey = new JobKey("test" , "test-1");

       JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();

       Trigger trigger = TriggerBuilder.newTrigger() .withIdentity("test" , "test")

       // 延迟一秒执行

       .startAt(new Date(System.currentTimeMillis() + 1000))

       // 每隔一秒执行 并一直重复

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

       .build();

       scheduler.scheduleJob(jobDetail , trigger);

       Thread.sleep(5000);

       // 删除job

       scheduler.deleteJob(jobKey);

       }

       3.Spring 相关的任务调度

       3.1 配置文件实现

       spring-schedule.xml

       <task:scheduler id="myScheduler" pool-size="10" />

       <task:scheduled-tasks scheduler="myScheduler">

       <task:scheduled ref="job" method="test" cron="0 * * * * ?"/>

       </task:scheduled-tasks>

       3.2注解实现

       spring-schedule.xml

       <task:scheduler id="myScheduler" pool-size="10" />

       // 启用注解

       <task:annotation-driven scheduler="myScheduler"/>

       @Component?

       public class Task{ ?

       @Scheduled(cron="0/5 * *? * * ? ")? //每5秒执行一次

       public void execute(){

       DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

       System.out.println(sdf.format(DateTime.now().toDate())+"*********B任务每5秒执行一次进入测试"); ?

       }?

       }

java中quartz定时任务的执行如何避免并发

       第一个例子。timer定时器。（这个比较简单，timer是Java.util包下一个类）

       为了更好的了解，我写了两个定时器类，很被集成TimerTask。

       public class MyTask extends TimerTask{

       int count = 0;

       public void run() {

       System.out.println("定时器TimerTask启动"+count);

       count++;

       }

       }

       ++++++++++++++++++++++++++++++++++++++++++++

       public class MyTaskB extends TimerTask{

       int count = 0;

       public void run() {

       System.out.println("定时器MyTaskB启动"+count);

       count++;

       }

       }

       +++++++++++++++++++++++++++++++++++++++++++

       在main方法中测试

       Timer timer=new Timer();

       /**

       * 定时器任务制定，执行

       * @param tag: 0.在指定的时间里，执行指定的任务；

       * 1.在指定的时间里，按照指定的延迟，重复执行指定任务；

       * 2.从指定的延迟后，执行指定任务；

       * 3.从指定的延迟后，按照指定的延迟，重复执行指定的任务。

       *

       * @param mydate:指定的执行时间。只有在tag等于0、1才需要指定。

       * @param delay: 延迟执行时间，毫秒数。只有在tag等于1、3才需要指定。

       * @param period:间隔执行时间，毫秒数。只有在tag等于4才需要指定。

       */

       //定时器，执行任务测试

       public static void main(String[] args) {

       new TestA().timer.schedule(new MyTask(), 1000);

       new TestA().timer.schedule(new MyTaskB(), 4000);

       }

       注：timer还可以在web中应用。直接把MyTask（）和MyTaskB（）里面的方法作修改即可，也可以在任务完成后关掉timer定时。

       总结：其实timer实现定时任务是很简单的，但是在想法开发是很少用到timer，而是用spring的Quartz。我也在网上找到了一些资料，现在总结一下。

       1. Java定时器没有持久化机制。

       2. Java定时器的日程管理不够灵活（只能设置开始时间、重复的间隔，设置特定的日期、时间等）//这点感同身受

       3. Java定时器没有使用线程池(每个Java定时器使用一个线程)//想必在用timer是遇到了吧。

       4. Java定时器没有切实的管理方案，你不得不自己完成存储、组织、恢复任务的措施

       一下例子是我在myeclipse中创建了一个小项目，仅供参考。

       第一步建立web项目（省略）

       第二步导入必要包：如下

       用到了一下包：

       （这九个包我就不多说了，想必大家都知道他的用处。）

       第三步：配置相关文件。web.xml、quartz.properties、quartz_job.xml这三个文件。这里我就没用spring的applicationContext.xml文件来管理了。其实原理都是一样，都是在web启动时监听并启动定时器。配置spring的quartz定时器有两种方法，一种是你用quartz.properties、quartz_job.xml，另外一种是用spring的applicationContext.xml。其实在开发的时候我还是比较喜欢前面一种，因为简单、方便，而用spring的applicationContext.xml里面本来就有各种配置，各种注入，是文件不够清晰（个人见解。呵呵）

       （项目中文件的位置，直接放在src目录下）

       第四步：web.xml文件配置（监听和启动定时器）

       <?xml version="1.0" encoding="UTF-8"?>

       <web-app version="2.4"

       xmlns="/xml/ns/j2ee"

       xmlns:xsi="/xml/ns/j2ee

       /xml/ns/j2ee/web-app_2_4.xsd">

       <listener>

       <listener-class>

       org.quartz.ee.servlet.QuartzInitializerListener

       </listener-class>

       </listener>

       <!-- timer -->

       <context-param>

       <param-name>config-file</param-name>

       <param-value>/quartz.properties</param-value>

       </context-param>

       <context-param>

       <param-name>shutdown-on-unload</param-name>

       <param-value>true</param-value>

       </context-param>

       <welcome-file-list>

       <welcome-file>index.jsp</welcome-file>

       </welcome-file-list>

       </web-app>

       第五步：配置quartz.properties文件

       org.quartz.scheduler.instanceName = TestScheduler

       org.quartz.scheduler.instanceId = one

       org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

       org.quartz.threadPool.threadCount = 2

       org.quartz.threadPool.threadPriority = 4

       org.quartz.plugin.jobInitializer.class = org.quartz.plugins.xml.JobInitializationPlugin

       org.quartz.plugin.jobInitializer.fileName = quartz_job.xml

       注解:主要主用是启动quartz_job.xml。其余的都是一些配置性能的属性，可以在网上查看。

       第六步：配置quartz_job.xml（里面主要配置定时器的一下属性）

       <?xml version="1.0" encoding="GBK"?>

       <quartz>

       <!-- 每1分钟执行一次 -->

       <job>

       <job-detail>

       <name>getDate</name><!-- 表示目标定时器的方法（也就是这个方法要定时的作用）-->

       <group>job</group>

       <job-class>com.timer.util.TimerTask</job-class><!-- 表示上面的getDate（）方法路径（即所在的包）-->

       </job-detail>

       <trigger>

       <cron>

       <name>t1</name>

       <group>job</group>

       <job-name>getDate</job-name>

       <job-group>job</job-group>

       <cron-expression>0 0/1 * * * ?</cron-expression><!-- 设置定时器的触发时间即间隔时间（参数形式可以在网上查到自己想要的形式）-->

       </cron>

       </trigger>

       </job>

       </quartz>

       第七步：写用两个类来测试定时器是否好用。

       public class TimerTask implements Job {

       private static Logger logger = Logger.getLogger(TimerTask.class);

       public void execute(JobExecutionContext arg0) throws JobExecutionException {

       try {

       TimerOperation.getDate();

       } catch (Exception ex) {

       logger.info(ex.getMessage());

       }

       }

       }

       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

       public class TimerOperation {

       private static Logger logger = Logger.getLogger(TimerOperation.class);

       public static void getDate()

       {

       String strCurrentDateTime = "";

       Date currentDateTime = new Date();

       SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

       strCurrentDateTime = formatter.format(currentDateTime);

       logger.info("定时器启动"+strCurrentDateTime);

       }

       }

       +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

       写这两个类就会看出，定时器不能直接调用自己写了定时方法，要先写一个类实现job的接口，然后在实现接口的execute()方法里面调用自己事先写好的定时任务。

       好了一个定时器就写好了。运行项目，等待一分钟控制台就会出现

Java中定时任务quartz如何将历史数据写入新表

       只要在detail的参数里加上一句话就行了，把这个job设置成有状态的job

       <property name="concurrent" value="false" />

       扩展：通过concurrent属性指定任务的类型，默认情况下封装为无状态的任务，如果希望目标封装为有状态的任务，仅需要将concurrent设置为false就可以了。Spring通过名为concurrent的属性指定任务的类型，能够更直接地描述到任务执行的方式（有状态的任务不能并发执行，无状态的任务可并发执行）

java定时方法执行力7-9个小时(quartz框架的定时方法),没有报错(日志没有错误)，却没有把方法执行完

       我建议的做法是在数据库中建一些Quartz的表，MySQL的建、删表脚本，最主要的修改是quartz.properties，如果你使用的是其他数据库，可以下载Quartz的distribution，在\docs\dbTables下。然后我们可以启动Bootstrap类，注册、运行定时任务。你可以发现MySQL的表中已经有此定时任务的记录了。

       然后你可以停止Bootstrap类，将Bootstrap类中关于注册、启动定时任务的代码删除或注释，然后启动Bootstrap类，看上一次操作注册的定时任务会不会继续运行。

       如无意外，看上一次操作注册的定时任务会继续运行。

quartz定时任务最小时间是多少

       这种问题不好凭空想象是什么问题，关键是日志打印要详细，把可能出现问题的代码前后都打印一句日志，在运行时就知道哪里出错了。

       以我的经验，很多这种问题出在数据库，当有两个线程同时在对一个表的数据进行增删时，容易导致这表被锁，所以程序就一直卡住。你看看是不是有两个定时器在操作一张表。或这个定时器的执行周期太短，quartz不管第一次执行完没，当第二次执行时间到后，就会执行

用java的Quartz包定时调用方法，我想实现每隔半小时调用一次方法，那个配置文件中时间的配置符号咋写的了

       Quartz是Job scheduling（作业调度）领域的一个开源项目，Quartz既可以单独使用也可以跟spring框架整合使用，在实际开发中一般会使用后者。使用Quartz可以开发一个或者多个定时任务，每个定时任务可以单独指定执行的时间，例如每隔1小时执行一次、每个月第一天上午10点执行一次、每个月最后一天下午5点执行一次等。

       主要配置的内容有

       配置自定义Job、任务描述、触发器、调度工厂等

       自动扫包

       注册任务对象

       注册JobDetail

       触发器

       调度工厂

       <!-- 常用的corn表达式

       *隔5秒执行一次：*/5 * * * * ?

       *隔1分钟执行一次：0 */1 * * * ?

       *23点执行一次：0 0 23 * * ?

       *晨1点执行一次：0 0 1 * * ?

       *月1号凌晨1点执行一次：0 0 1 1 * ?

       *月最后一天23点执行一次：0 0 23 L * ?

       *周星期天凌晨1点实行一次：0 0 1 ? * L

       *在26分、29分、33分执行一次：0 26,29,33 * * * ?

       *的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?

       -->

       这是spring调用时，的符号公式

       好了，今天关于“java quartz 定时器”的话题就到这里了。希望大家能够通过我的讲解对“java quartz 定时器”有更全面、深入的了解，并且能够在今后的生活中更好地运用所学知识。