码迷，mamicode.com
首页 > 编程语言 > 详细

java实现定时任务 Schedule

时间：2017-08-12 21:15:36      阅读：325      评论：0      收藏：0      [点我收藏+]

标签：exce   复杂   区分   copy   unit   while   target   创建   obd   

1.java定时任务可以借助 java.util.Timer 来实现

 

[java] view plain copy
 
  1. import java.util.Calendar;  
  2. import java.util.Date;  
  3. import java.util.Timer;  
  4. import java.util.TimerTask;  
  5.   
  6. public class Test {  
  7.     public static void main(String[] args) {  
  8.         //timer1();  
  9.         timer2();  
  10.         //timer3();  
  11.         //timer4();  
  12.     }  
  13.   
  14.     // 第一种方法：设定指定任务task在指定时间time执行 schedule(TimerTask task, Date time)  
  15.     public static void timer1() {  
  16.         Timer timer = new Timer();  
  17.         timer.schedule(new TimerTask() {  
  18.             public void run() {  
  19.                 System.out.println("-------设定要指定任务--------");  
  20.             }  
  21.         }, 2000);// 设定指定的时间time,此处为2000毫秒  
  22.     }  
  23.   
  24.     // 第二种方法：设定指定任务task在指定延迟delay后进行固定延迟peroid的执行  
  25.     // schedule(TimerTask task, long delay, long period)  
  26.     public static void timer2() {  
  27.         Timer timer = new Timer();  
  28.         timer.schedule(new TimerTask() {  
  29.             public void run() {  
  30.                 System.out.println("-------设定要指定任务--------");  
  31.             }  
  32.         }, 1000, 1000);  
  33.     }  
  34.   
  35.     // 第三种方法：设定指定任务task在指定延迟delay后进行固定频率peroid的执行。  
  36.     // scheduleAtFixedRate(TimerTask task, long delay, long period)  
  37.     public static void timer3() {  
  38.         Timer timer = new Timer();  
  39.         timer.scheduleAtFixedRate(new TimerTask() {  
  40.             public void run() {  
  41.                 System.out.println("-------设定要指定任务--------");  
  42.             }  
  43.         }, 1000, 2000);  
  44.     }  
  45.      
  46.     // 第四种方法：安排指定的任务task在指定的时间firstTime开始进行重复的固定速率period执行．  
  47.     // Timer.scheduleAtFixedRate(TimerTask task,Date firstTime,long period)  
  48.     public static void timer4() {  
  49.         Calendar calendar = Calendar.getInstance();  
  50.         calendar.set(Calendar.HOUR_OF_DAY, 12); // 控制时  
  51.         calendar.set(Calendar.MINUTE, 0);       // 控制分  
  52.         calendar.set(Calendar.SECOND, 0);       // 控制秒  
  53.   
  54.         Date time = calendar.getTime();         // 得出执行任务的时间,此处为今天的12：00：00  
  55.   
  56.         Timer timer = new Timer();  
  57.         timer.scheduleAtFixedRate(new TimerTask() {  
  58.             public void run() {  
  59.                 System.out.println("-------设定要指定任务--------");  
  60.             }  
  61.         }, time, 1000 * 60 * 60 * 24);// 这里设定将延时每天固定执行  
  62.     }  
  63. }  

 

 

2. Java定时任务可以用线程的等待来实现

 

[java] view plain copy
 
  1. /**  
  2.  * 普通thread  
  3.  * 这是最常见的，创建一个thread，然后让它在while循环里一直运行着，  
  4.  * 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：  
  5.  * @author GT  
  6.  *  
  7.  */    
  8. public class Task1 {    
  9.     public static void main(String[] args) {    
  10.         // run in a second    
  11.         final long timeInterval = 1000;    
  12.         Runnable runnable = new Runnable() {    
  13.             public void run() {    
  14.                 while (true) {    
  15.                     // ------- code for task to run    
  16.                     System.out.println("Hello !!");    
  17.                     // ------- ends here    
  18.                     try {    
  19.                         Thread.sleep(timeInterval);    
  20.                     } catch (InterruptedException e) {    
  21.                         e.printStackTrace();    
  22.                     }    
  23.                 }    
  24.             }    
  25.         };    
  26.         Thread thread = new Thread(runnable);    
  27.         thread.start();    
  28.     }    
  29. }   

 

 

3.Java可以用java.util.concurrent.ScheduledExecutorService 来实现定时任务

 

[java] view plain copy
 
  1. import java.util.concurrent.Executors;    
  2. import java.util.concurrent.ScheduledExecutorService;    
  3. import java.util.concurrent.TimeUnit;    
  4.     
  5. /**  
  6.  *   
  7.  *   
  8.  * ScheduledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。   
  9.  * 相比于上两个方法，它有以下好处：  
  10.  * 1>相比于Timer的单线程，它是通过线程池的方式来执行任务的   
  11.  * 2>可以很灵活的去设定第一次执行任务delay时间  
  12.  * 3>提供了良好的约定，以便设定执行的时间间隔  
  13.  *   
  14.  * 下面是实现代码，我们通过ScheduledExecutorService#scheduleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间。  
  15.  *   
  16.  *   
  17.  * @author GT  
  18.  *   
  19.  */    
  20. public class Task3 {    
  21.     public static void main(String[] args) {    
  22.         Runnable runnable = new Runnable() {    
  23.             public void run() {    
  24.                 // task to run goes here    
  25.                 System.out.println("Hello !!");    
  26.             }    
  27.         };    
  28.         ScheduledExecutorService service = Executors    
  29.                 .newSingleThreadScheduledExecutor();    
  30.         // 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间    
  31.         service.scheduleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);    
  32.     }    
  33. }    

 

 

4. 定时任务之-Quartz使用篇

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的日程序表。Jobs可以做成标准的Java组件或 EJBs。

 

 

CronTrigger配置格式:
格式: [秒] [分] [小时] [日] [月] [周] [年]

序号 说明 是否必填 允许填写的值 允许的通配符
1 秒 是 0-59 , - * /
2 分 是 0-59 , - * /
3 小时 是 0-23 , - * /
4 日 是 1-31 , - * ? / L W
5 月 是 1-12 or JAN-DEC , - * /
6 周 是 1-7 or SUN-SAT , - * ? / L #
7 年 否 empty 或 1970-2099 , - * /

 

通配符说明:
* 表示所有值. 例如:在分的字段上设置 "*",表示每一分钟都会触发。
? 表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10* ?
- 表示区间。例如 在小时上设置 "10-12",表示 10,11,12点都会触发。
, 表示指定多个值，例如在周字段上设置 "MON,WED,FRI" 表示周一，周三和周五触发
/ 用于递增触发。如在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。在月字段上设置‘1/3‘所示每月1号开始，每隔三天触发一次。
L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。如果在"L"前加上数字，则表示该数据的最后一个。例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五"
W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 "1W",它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，"W"前只能设置具体的数字,不允许区间"-").

小提示

‘L‘和 ‘W‘可以一组合使用。如果在日字段上设置"LW",则表示在本月的最后一个工作日触发(一般指发工资技术分享 ) 

# 序号(表示每月的第几个周几)，例如在周字段上设置"6#3"表示在每月的第三个周六.注意如果指定"#5",正好第五周没有周六，则不会触发该配置(用在母亲节和父亲节再合适不过了)

小提示 周字段的设置，若使用英文字母是不区分大小写的 MON 与mon相同.

 

常用示例:

0 0 12 * * ? 每天12点触发
0 15 10 ? * * 每天10点15分触发
0 15 10 * * ? 每天10点15分触发
0 15 10 * * ? * 每天10点15分触发
0 15 10 * * ? 2005 2005年每天10点15分触发
0 * 14 * * ? 每天下午的 2点到2点59分每分触发
0 0/5 14 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发)
0 0/5 14,18 * * ? 每天下午的 2点到2点59分(整点开始，每隔5分触发)每天下午的 18点到18点59分(整点开始，每隔5分触发)
0 0-5 14 * * ? 每天下午的 2点到2点05分每分触发
0 10,44 14 ? 3 WED 3月分每周三下午的 2点10分和2点44分触发
0 15 10 ? * MON-FRI 从周一到周五每天上午的10点15分触发
0 15 10 15 * ? 每月15号上午10点15分触发
0 15 10 L * ? 每月最后一天的10点15分触发
0 15 10 ? * 6L 每月最后一周的星期五的10点15分触发
0 15 10 ? * 6L 2002-2005 从2002年到2005年每月最后一周的星期五的10点15分触发
0 15 10 ? * 6#3 每月的第三周的星期五开始触发
0 0 12 1/5 * ? 每月的第一个中午开始每隔5天触发一次
0 11 11 11 11 ? 每年的11月11号 11点11分触发(光棍节)

经过封装的管理类：

 

[java] view plain copy
 
  1. import java.text.ParseException;    
  2.     
  3. import org.quartz.CronTrigger;    
  4. import org.quartz.JobDetail;    
  5. import org.quartz.Scheduler;    
  6. import org.quartz.SchedulerException;    
  7. import org.quartz.SchedulerFactory;    
  8. import org.quartz.impl.StdSchedulerFactory;    
  9.     
  10. /**  
  11.  * 定时任务管理类  
  12.  *  
  13.  */    
  14. public class QuartzManager {    
  15.     private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();    
  16.     private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME";    
  17.     private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME";    
  18.     
  19.     /**  
  20.      * 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名  
  21.      *  
  22.      * @param jobName  
  23.      *            任务名  
  24.      * @param jobClass  
  25.      *            任务  
  26.      * @param time  
  27.      *            时间设置，参考quartz说明文档  
  28.      * @throws SchedulerException  
  29.      * @throws ParseException  
  30.      */    
  31.     public static void addJob(String jobName, String jobClass, String time) {    
  32.         try {    
  33.             Scheduler sched = gSchedulerFactory.getScheduler();    
  34.             JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, Class.forName(jobClass));// 任务名，任务组，任务执行类    
  35.             // 触发器    
  36.             CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组    
  37.             trigger.setCronExpression(time);// 触发器时间设定    
  38.             sched.scheduleJob(jobDetail, trigger);    
  39.             // 启动    
  40.             if (!sched.isShutdown()){    
  41.                 sched.start();    
  42.             }    
  43.         } catch (Exception e) {    
  44.             e.printStackTrace();    
  45.             throw new RuntimeException(e);    
  46.         }    
  47.     }    
  48.     
  49.     /**  
  50.      * 添加一个定时任务  
  51.      *  
  52.      * @param jobName  
  53.      *            任务名  
  54.      * @param jobGroupName  
  55.      *            任务组名  
  56.      * @param triggerName  
  57.      *            触发器名  
  58.      * @param triggerGroupName  
  59.      *            触发器组名  
  60.      * @param jobClass  
  61.      *            任务  
  62.      * @param time  
  63.      *            时间设置，参考quartz说明文档  
  64.      * @throws SchedulerException  
  65.      * @throws ParseException  
  66.      */    
  67.     public static void addJob(String jobName, String jobGroupName,    
  68.             String triggerName, String triggerGroupName, String jobClass, String time){    
  69.         try {    
  70.             Scheduler sched = gSchedulerFactory.getScheduler();    
  71.             JobDetail jobDetail = new JobDetail(jobName, jobGroupName, Class.forName(jobClass));// 任务名，任务组，任务执行类    
  72.             // 触发器    
  73.             CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组    
  74.             trigger.setCronExpression(time);// 触发器时间设定    
  75.             sched.scheduleJob(jobDetail, trigger);    
  76.         } catch (Exception e) {    
  77.             e.printStackTrace();    
  78.             throw new RuntimeException(e);    
  79.         }    
  80.     }    
  81.     
  82.     /**  
  83.      * 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)  
  84.      *  
  85.      * @param jobName  
  86.      * @param time  
  87.      */    
  88.     public static void modifyJobTime(String jobName, String time) {    
  89.         try {    
  90.             Scheduler sched = gSchedulerFactory.getScheduler();    
  91.             CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName, TRIGGER_GROUP_NAME);    
  92.             if(trigger == null) {    
  93.                 return;    
  94.             }    
  95.             String oldTime = trigger.getCronExpression();    
  96.             if (!oldTime.equalsIgnoreCase(time)) {    
  97.                 JobDetail jobDetail = sched.getJobDetail(jobName, JOB_GROUP_NAME);    
  98.                 Class objJobClass = jobDetail.getJobClass();    
  99.                 String jobClass = objJobClass.getName();    
  100.                 removeJob(jobName);    
  101.     
  102.                 addJob(jobName, jobClass, time);    
  103.             }    
  104.         } catch (Exception e) {    
  105.             e.printStackTrace();    
  106.             throw new RuntimeException(e);    
  107.         }    
  108.     }    
  109.     
  110.     /**  
  111.      * 修改一个任务的触发时间  
  112.      *  
  113.      * @param triggerName  
  114.      * @param triggerGroupName  
  115.      * @param time  
  116.      */    
  117.     public static void modifyJobTime(String triggerName,    
  118.             String triggerGroupName, String time) {    
  119.         try {    
  120.             Scheduler sched = gSchedulerFactory.getScheduler();    
  121.             CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, triggerGroupName);    
  122.             if(trigger == null) {    
  123.                 return;    
  124.             }    
  125.             String oldTime = trigger.getCronExpression();    
  126.             if (!oldTime.equalsIgnoreCase(time)) {    
  127.                 CronTrigger ct = (CronTrigger) trigger;    
  128.                 // 修改时间    
  129.                 ct.setCronExpression(time);    
  130.                 // 重启触发器    
  131.                 sched.resumeTrigger(triggerName, triggerGroupName);    
  132.             }    
  133.         } catch (Exception e) {    
  134.             e.printStackTrace();    
  135.             throw new RuntimeException(e);    
  136.         }    
  137.     }    
  138.     
  139.     /**  
  140.      * 移除一个任务(使用默认的任务组名，触发器名，触发器组名)  
  141.      *  
  142.      * @param jobName  
  143.      */    
  144.     public static void removeJob(String jobName) {    
  145.         try {    
  146.             Scheduler sched = gSchedulerFactory.getScheduler();    
  147.             sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器    
  148.             sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器    
  149.             sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务    
  150.         } catch (Exception e) {    
  151.             e.printStackTrace();    
  152.             throw new RuntimeException(e);    
  153.         }    
  154.     }    
  155.     
  156.     /**  
  157.      * 移除一个任务  
  158.      *  
  159.      * @param jobName  
  160.      * @param jobGroupName  
  161.      * @param triggerName  
  162.      * @param triggerGroupName  
  163.      */    
  164.     public static void removeJob(String jobName, String jobGroupName,    
  165.             String triggerName, String triggerGroupName) {    
  166.         try {    
  167.             Scheduler sched = gSchedulerFactory.getScheduler();    
  168.             sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器    
  169.             sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器    
  170.             sched.deleteJob(jobName, jobGroupName);// 删除任务    
  171.         } catch (Exception e) {    
  172.             e.printStackTrace();    
  173.             throw new RuntimeException(e);    
  174.         }    
  175.     }    
  176.     
  177.     /**  
  178.      * 启动所有定时任务  
  179.      */    
  180.     public static void startJobs() {    
  181.         try {    
  182.             Scheduler sched = gSchedulerFactory.getScheduler();    
  183.             sched.start();    
  184.         } catch (Exception e) {    
  185.             e.printStackTrace();    
  186.             throw new RuntimeException(e);    
  187.         }    
  188.     }    
  189.     
  190.     /**  
  191.      * 关闭所有定时任务  
  192.      */    
  193.     public static void shutdownJobs() {    
  194.         try {    
  195.             Scheduler sched = gSchedulerFactory.getScheduler();    
  196.             if(!sched.isShutdown()) {    
  197.                 sched.shutdown();    
  198.             }    
  199.         } catch (Exception e) {    
  200.             e.printStackTrace();    
  201.             throw new RuntimeException(e);    
  202.         }    
  203.     }    
  204. }    


简单实现Schedule的Quartz的例子

 

　第一步：引包

　　要使用Quartz，必须要引入以下这几个包：

　　1、log4j-1.2.16

　　2、quartz-2.1.7

　　3、slf4j-api-1.6.1.jar

　　4、slf4j-log4j12-1.6.1.jar

　　这些包都在下载的Quartz包里面包含着，因此没有必要为寻找这几个包而头疼。

　　第二步：创建要被定执行的任务类

　　这一步也很简单，只需要创建一个实现了org.quartz.Job接口的类，并实现这个接口的唯一一个方法execute(JobExecutionContext arg0) throws JobExecutionException即可。如：

[java] view plain copy
 
  1. import java.text.SimpleDateFormat;   
  2.    
  3. import java.util.Date;   
  4.    
  5. import org.quartz.Job;   
  6. import org.quartz.JobExecutionContext;   
  7. import org.quartz.JobExecutionException;   
  8.    
  9. public class myJob implements Job {   
  10.    
  11.     @Override   
  12.     public void execute(JobExecutionContext arg0) throws JobExecutionException {   
  13.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");   
  14.         System.out.println(sdf.format(new Date()));   
  15.     }   
  16.    
  17. }   


　第三步：创建任务调度，并执行

 

[java] view plain copy
 
    1. import java.text.SimpleDateFormat;  
    2. import java.util.Date;  
    3.   
    4. import org.quartz.CronTrigger;  
    5. import org.quartz.JobDetail;  
    6. import org.quartz.Scheduler;  
    7. import org.quartz.SchedulerFactory;  
    8. import org.quartz.impl.StdSchedulerFactory;  
    9.   
    10. public class Test {  
    11.     public void go() throws Exception {  
    12.         // 首先，必需要取得一个Scheduler的引用  
    13.         SchedulerFactory sf = new StdSchedulerFactory();  
    14.         Scheduler sched = sf.getScheduler();  
    15.         String time="0 51 11 ? * *";  
    16.         // jobs可以在scheduled的sched.start()方法前被调用  
    17.   
    18.         // job 1将每隔20秒执行一次  
    19.         JobDetail job = new JobDetail("job1", "group1", myJob.class);  
    20.         CronTrigger trigger = new CronTrigger("trigger1", "group1");  
    21.         trigger.setCronExpression(time);  
    22.         Date ft = sched.scheduleJob(job, trigger);  
    23.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");  
    24.         System.out.println(  
    25.                 job.getKey() + " 已被安排执行于: " + sdf.format(ft) + "，并且以如下重复规则重复执行: " + trigger.getCronExpression());  
    26.   
    27.         // job 2将每2分钟执行一次（在该分钟的第15秒)  
    28.         job = new JobDetail("job2", "group1",myJob.class);  
    29.         trigger = new CronTrigger("trigger2", "group1");  
    30.         trigger.setCronExpression(time);  
    31.         ft = sched.scheduleJob(job, trigger);  
    32.         System.out.println(  
    33.                 job.getKey() + " 已被安排执行于: " + sdf.format(ft) + "，并且以如下重复规则重复执行: " + trigger.getCronExpression());  
    34.   
    35.         // 开始执行，start()方法被调用后，计时器就开始工作，计时调度中允许放入N个Job  
    36.         sched.start();  
    37.         try {  
    38.             // 主线程等待一分钟  
    39.             Thread.sleep(60L * 1000L);  
    40.         } catch (Exception e) {  
    41.         }  
    42.         // 关闭定时调度，定时器不再工作  
    43.         sched.shutdown(true);  
    44.     }  
    45.   
    46.     public static void main(String[] args) throws Exception {  
    47.   
    48.         Test test = new Test();  
    49.         test.go();  
    50.     }  
    51.   
    52. }  

java实现定时任务 Schedule

标签：exce   复杂   区分   copy   unit   while   target   创建   obd   

原文地址：http://www.cnblogs.com/DaTouDaddy/p/7351352.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！