精华内容
下载资源
问答
  • java定时任务实现几种方式

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

    摘要:    在开发测试工具的应用后台,经常听到同事说要做个定时任务把做日志处理,或者数据清理,包括做些复杂的业务计算逻辑,在选择定时任务的时候,怎么能够快速实现,并且选择一种更适合自己的方式呢? 我这里把定时任务的实现收集整理了一些方法,希望可以帮到刚开始做定时任务的同学,写得不对的地方请指正。 

    一 

       在开发测试工具的应用后台,经常听到同事说要做个定时任务把做日志处理,或者数据清理,包括做些复杂的业务计算逻辑,在选择定时任务的时候,怎么能够快速实现,并且选择一种更适合自己的方式呢? 我这里把定时任务的实现收集整理了一些方法,希望可以帮到刚开始做定时任务的同学,写得不对的地方请指正。
     

    一  Java 基本的定时任务,总结方法有三种:

          1.1   创建一个thread,然后让它在while循环里一直运行着,通过sleep方法来达到定时任务的效果;
          

    1.2   用Timer和TimerTask与第一种方法相比有如下好处:

    • 当启动和去取消任务时可以控制

    • 第一次执行任务时可以指定你想要的delay时间

     1.3   用ScheduledExecutorService是从的java.util.concurrent里,做为并发工具类被引进的,这是最理想的定时任务实现方式,相比于上两个方法,它有以下好处:

    • 相比于Timer的单线程,它是通过线程池的方式来执行任务的

    • 可以很灵活的去设定第一次执行任务delay时间

    • 提供了良好的约定,以便设定执行的时间间隔


    二  Spring 定时任务,总结方式也有三种:

      2.1    ScheduledTimerTask:  Spring的ScheduledTimerTask定义了一个定时器任务的运行周期,遗憾的是,你可以指定任务执行的频度,但你无法精确指定它何时运行,这就需要用到第二种Quartz进行任务调度;

    •        创建一个业务任务,在Spring配置文件中声明 ;

    •        在Spring 配置文件中,配置ScheduledTimerTask ,并且关联上自定义的任务实例;

    •        启动定时器,Spring的TimerFactoryBean负责启动定时任务

     
      

     2.2    使用 Quartz:

    •       首先还是老样子定义业务逻辑任务:

    在Spring中声明并且配置作业调度的触发方式

    这里 Quartz的作业触发器有两种,分别是

    org.springframework.scheduling.quartz.SimpleTriggerBean
    
    org.springframework.scheduling.quartz.CronTriggerBean
    
    
    
    第一种SimpleTriggerBean,只支持按照一定频度调用任务,如每隔一段时间运行一次。
    
    <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">  
    
        <property name="jobDetail" ref="myJob" />  
    
        <property name="startDelay" value="0" /><!-- 调度工厂实例化后,经过0秒开始执行调度 -->  
    
        <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 -->  
    
    </bean> 

     

    第二种CronTriggerBean,支持到指定时间运行一次,如每天12:00运行一次,如上配置;

    • 配置调度工厂

    org.springframework.scheduling.quartz.SchedulerFactoryBean,代码如上;

    • 启动你的应用即可

     2.3   使用 Spring-Task

             Spring自带的定时任务工具,spring task,可以将它比作一个轻量级的Quartz,而且使用起来很简单,除spring相关的包外不需要额外的包,而且支持注解和配置文件两种:

             第一步:编写任务类;TaskJob,method job1  --代码省略

             第二步:在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:scheduled-tasks>   
    
            <task:scheduled ref="taskJob" method="job1" cron="0 * * * * ?"/>   
    
    </task:scheduled-tasks>  
    
    <context:component-scan base-package="com.alibaba.mytask" /> 

    说明:ref参数指定的即任务类,method指定的即需要运行的方法,cron及cronExpression表达式,具体写法这里不介绍了,<context:component-scan base-package="com.alibaba.mytask" />spring扫描注解用的。

     

    以上示例有一处小坑,一眼能看出的小问题,考验大家调试和解决问题的能力,拒绝不理解思路完全复制代码的行为

    有问题可以评论,看到后会及时回复.

     

    展开全文
  • Java 定时任务几种实现方式

    万次阅读 多人点赞 2017-06-03 22:04:51
    JAVA实现定时任务的几种方式@(JAVA)[spring|quartz|定时器]  近期项目开发中需要动态的添加定时任务,比如在某个活动结束时,自动生成获奖名单,导出excel等,此类任务由于活动时间... 目前主要有以下几种实现方式

    JAVA实现定时任务的几种方式

    @(JAVA)[spring|quartz|定时器]
      近期项目开发中需要动态的添加定时任务,比如在某个活动结束时,自动生成获奖名单,导出excel等,此类任务由于活动时间是动态的,不能把定时任务配置在配置文件或写死在代码中。当然也可以增加一个定时扫描的任务来实现。借此机会整理了AVA实现定时任务的几种常用方式,以下做简要介绍。
    目前主要有以下几种实现方式:
    - JDK自带 :JDK自带的Timer以及JDK1.5+ 新增的ScheduledExecutorService;
    - Quartz :简单却强大的JAVA作业调度框架
    - Spring3.0以后自带的task :可以将它看成一个轻量级的Quartz,而且使用起来比Quartz简单许多;
    下面将一一介绍以上三种实现方式。


    JDK 自带的定时器实现

    • Timer类
      这个类允许你调度一个java.util.TimerTask任务。主要有以下几个方法:
    
    1. schedule(TimerTask task, long delay) 延迟 delay 毫秒 执行
    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 ");
                    }
                }, 1000);
            }
        }
    out :
    timer - 2 run 
    timer - 1 run 
    timer - 0 run 
    timer - 3 run 
    timer - 9 run 
    timer - 4 run 
    timer - 8 run 
    timer - 5 run 
    timer - 6 run 
    timer - 7 run 
    
    2. 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));
            }
        }
    out:
    timer - 0 run 
    timer - 7 run 
    timer - 6 run 
    timer - 8 run 
    timer - 3 run 
    timer - 5 run 
    timer - 2 run 
    timer - 1 run 
    timer - 4 run 
    timer - 9 run 
    
    3. schedule(TimerTask task, long delay, long period) 延迟 delay 执行并每隔period 执行一次
    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 ");
                    }
                }, 2000 , 3000);
            }
        }
    out:
    timer - 0 run 
    timer - 5 run 
    timer - 4 run 
    timer - 8 run 
    timer - 3 run 
    timer - 2 run 
    timer - 1 run 
    timer - 7 run 
    timer - 9 run 
    timer - 6 run 
    timer - 3 run 
    timer - 7 run 
    timer - 5 run 
    timer - 4 run 
    timer - 8 run 
    • ScheduledExecutorService 接口实现类
      ScheduledExecutorService 是JAVA 1.5 后新增的定时任务接口,主要有以下几个方法。
    - ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit);
    - <V> ScheduledFuture<V> schedule(Callable<V> callable,long delay, TimeUnit unit);
    - ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnitunit);
    - ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnitunit);

    默认实现为ScheduledThreadPoolExecutor 继承了ThreadPoolExecutor 的线程池特性,配合future特性,比Timer更强大。 具体用法可以阅读JDK文档;spring Task内部也是依靠它实现的。示例代码:

    public static void main(String[] args) throws SchedulerException {
            ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor)Executors.newScheduledThreadPool(10);
            for (int i = 0; i < 10; ++i) {
                executor.schedule(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + " run ");
                    }
                } , 2 , TimeUnit.SECONDS);
            }
            executor.shutdown();
        }
    
    out:
    pool-1-thread-2 run 
    pool-1-thread-5 run 
    pool-1-thread-4 run 
    pool-1-thread-3 run 
    pool-1-thread-8 run 
    pool-1-thread-5 run 
    pool-1-thread-7 run 
    pool-1-thread-2 run 
    pool-1-thread-1 run 
    pool-1-thread-6 run 

    Quartz 定时器实现

    Quartz是一个完全由Java编写的开源作业调度框架,为在Java应用程序中进行作业调度提供了简单却强大的机制。Quartz允许开发人员根据时间间隔来调度作业。它实现了作业和触发器的多对多的关系,还能把多个作业与不同的触发器关联。可以动态的添加删除定时任务,另外很好的支撑集群调度。简单地创建一个org.quarz.Job接口的Java类,Job接口包含唯一的方法:

    public void execute(JobExecutionContext context) throws JobExecutionException;
    

    在Job接口实现类里面,添加需要的逻辑到execute()方法中。配置好Job实现类并设定好调度时间表(Trigger),Quartz就会自动在设定的时间调度作业执行execute()。

    整合了Quartz的应用程序可以重用不同事件的作业,还可以为一个事件组合多个作业。Quartz通过属性文件来配置JDBC事务的数据源、全局作业、触发器侦听器、插件、线程池等等。(quartz.properties)

    1. 通过maven引入依赖(这里主要介绍2.3.0) 注意:shiro-scheduler中依赖的是1.x版本 如果同时使用会冲突
    <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.3.0</version>
            </dependency>
    1. 创建Job类
    public class TestJob implements Job{
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            println(Thread.currentThread().getName() + " test job begin " + DateUtil.getCurrentTimeStr());
        }
    }
    1. 调度任务
    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);
        }
    
    out :
    DefaultQuartzScheduler_Worker-1test job begin 2017-06-03 14:30:33
    DefaultQuartzScheduler_Worker-2test job begin 2017-06-03 14:30:34
    DefaultQuartzScheduler_Worker-3test job begin 2017-06-03 14:30:35
    DefaultQuartzScheduler_Worker-4test job begin 2017-06-03 14:30:36
    DefaultQuartzScheduler_Worker-5test job begin 2017-06-03 14:30:37

    Quartz 主要包含以下几个部分

    Job:是一个接口,只有一个方法void execute(JobExecutionContext

    context),开发者实现该接口定义运行任务,JobExecutionContext类提供了调度上下文的各种信息。Job运行时的信息保存在JobDataMap实例中;

    JobDetail:Quartz在每次执行Job时,都重新创建一个Job实例,所以它不直接接受一个Job的实例,相反它接收一个Job实现类,以便运行时通过newInstance()的反射机制实例化Job。因此需要通过一个类来描述Job的实现类及其它相关的静态信息,如Job名字、描述、关联监听器等信息,JobDetail承担了这一角色。

    Trigger:是一个类,描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当仅需触发一次或者以固定时间间隔周期执行,SimpleTrigger是最适合的选择;而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案:如每早晨9:00执行,周一、周三、周五下午5:00执行等;

    Calendar:org.quartz.Calendar和java.util.Calendar不同,它是一些日历特定时间点的集合(可以简单地将org.quartz.Calendar看作java.util.Calendar的集合——java.util.Calendar代表一个日历时间点,无特殊说明后面的Calendar即指org.quartz.Calendar)。一个Trigger可以和多个Calendar关联,以便排除或包含某些时间点。假设,我们安排每周星期一早上10:00执行任务,但是如果碰到法定的节日,任务则不执行,这时就需要在Trigger触发机制的基础上使用Calendar进行定点排除。

    Scheduler:代表一个Quartz的独立运行容器,Trigger和JobDetail可以注册到Scheduler中,两者在Scheduler中拥有各自的组及名称,组及名称是Scheduler查找定位容器中某一对象的依据,Trigger的组及名称必须唯一,JobDetail的组和名称也必须唯一(但可以和Trigger的组和名称相同,因为它们是不同类型的)。Scheduler定义了多个接口方法,允许外部通过组及名称访问和控制容器中Trigger和JobDetail。

    Scheduler可以将Trigger绑定到某一JobDetail中,这样当Trigger触发时,对应的Job就被执行。一个Job可以对应多个Trigger,但一个Trigger只能对应一个Job。可以通过SchedulerFactory创建一个Scheduler实例。Scheduler拥有一个SchedulerContext,它类似于ServletContext,保存着Scheduler上下文信息,Job和Trigger都可以访问SchedulerContext内的信息。SchedulerContext内部通过一个Map,以键值对的方式维护这些上下文数据,SchedulerContext为保存和获取数据提供了多个put()和getXxx()的方法。可以通过Scheduler#

    getContext()获取对应的SchedulerContext实例;

    ThreadPool:Scheduler使用一个线程池作为任务运行的基础设施,任务通过共享线程池中的线程提高运行效率。

    关于简单使用,可以参考quartz的example,下面链接是一些入门帮助。

    Quartz定时任务学习(一)简单任务
    Quartz定时任务学习(二)web应用
    Quartz定时任务学习(三)属性文件和jar

    深入学习可以阅读官方文档和相关博客阅读
    以下为推荐博客地址
    quartz详解2:quartz由浅入深

    Spring 相关的任务调度

    1. Spring 3.0+ 自带的任务调度实现,主要依靠TaskScheduler接口的几个实现类实现。删除和修改任务比较麻烦。
      主要用法有以下三种:
      • Spring配置文件实现
      • 注解实现
      • 代码动态添加

    配置文件实现

    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>

    注解实现

    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秒执行一次进入测试");      
           }      
    }  

    代码动态添加

    spring-schedule.xml
    
    <bean id = "myScheduler" class="org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler">
            <property name="poolSize" value="10"/>
            <property name="threadGroupName" value="myScheduler" />
            <property name="threadNamePrefix" value="-1" />
    </bean>
    <task:annotation-driven scheduler="myScheduler"/> 
    @Component
    public class Test {
    
        @Autowired
        private ThreadPoolTaskScheduler myScheduler;
    
        public void addJob(){
    
            myScheduler.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + " run ");
                }
            } , new CronTrigger("0/5 * *  * * ? ")); //每5秒执行一次
        }
    }
    1. spring 结合 quartz 实现任务调度
      • spring 配置文件 spring-quartz.xml
    <bean id="quartzsScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false">
            <property name="triggers">
                <list>
                <ref bean="testTrigger" />
                </list>
            </property>
    </bean>
    
    <!-- jobClass需要继承QuartzJobBean  也可以使用 MethodInvokingJobDetailFactoryBean 定义任意类任意方法为Job-->
    <bean id="testJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
                  <property name="jobClass">
                         <value>com.test.TestJob</value>
                  </property>
                  <property name="durability" value="true" />
                  <!-- requestsRecovery属性必须设置为 true,当Quartz服务被中止后,再次启动或集群中其他机器接手任务时会尝试恢复执行之前未完成的所有任务 -->
                  <property name="requestsRecovery" value="true" />
    </bean>
    <bean id="testTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
                  <property name="jobDetail" ref="testJobDetail" />
                  <property name="cronExpression" value="0 0 10 * * ?" />
    </bean>

    动态增加删除

    @Component
    public class Test {
    
        @Autowired
        private SchedulerFactoryBean quartzScheduler;
    
        public void addJob() throws SchedulerException {
    
            Scheduler scheduler = quartzScheduler.getScheduler();
            JobKey jobKey = new JobKey("test", "test");
            if (scheduler.checkExists(jobKey)) {
                return;
            }
            JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("test", "test")
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever()).build();
            scheduler.scheduleJob(jobDetail, trigger);
        }
    }

    以上仅仅是对自己学习的总结,深入了解还需查找相关资料。比如动态增加,修改定时任务。以及Quartz的集群模式等。

    展开全文
  • Java 定时任务几种实现方式总结

    千次阅读 2018-06-29 16:53:10
    java定时任务主要有以下几种实现方式:(1)JDK 自带的定时器实现(2)Quartz 定时器实现(3)Spring 相关的任务调度1、JDK自带的java.util.Timer 来实现import java.util.Calendar; import java.util.Date; import ...

    java定时任务主要有以下几种实现方式:

    (1)JDK 自带的定时器实现

    (2)Quartz 定时器实现

    (3)Spring 相关的任务调度

    1、JDK自带的java.util.Timer 来实现
    import java.util.Calendar;
    import java.util.Date;
    import java.util.Timer;
    import java.util.TimerTask;
    
    
    public class Test {
    	/**
    	 *  第一种方法:设定指定任务task在指定时间执行,只执行一次  
    	 *  schedule(TimerTask task, Date time)  
    	 */
        public static void timer1() {  
            Timer timer = new Timer();  
            timer.schedule(new TimerTask() {  
                public void run() {  
                    System.out.println(new Date() +"\t"+"---指定要执行任务---");  
                }  
            },  new Date(System.currentTimeMillis() + 2000)); 
        }  
        
        /**
         *  第二种方法:设定指定任务task在延迟delay执行,只执行一次    
         *  schedule(TimerTask task, long delay)   
         *  delay单位毫秒
         */
        public static void timer2(){
        	Timer timer = new Timer();  
            timer.schedule(new TimerTask() {  
                public void run() {  
                	System.out.println(new Date() +"\t"+"---指定要执行任务---");  
                }  
            }, 2000);  
        }
        
        /**
         *  第三种方法:设定指定任务task在指定延迟delay后进行周期性执行,周期时间为period  
         *  schedule(TimerTask task, long delay, long period) 
         *  scheduleAtFixedRate(TimerTask task, long delay, long period)  
         *  delay,period 单位为毫秒
         */
        public static void timer3() {  
            Timer timer = new Timer();  
            timer.schedule(new TimerTask() {  
                public void run() {  
                	System.out.println(new Date() +"\t"+"---指定要执行任务---");  
                }  
            }, 1000, 1000);  
        }  
        /**
         *  第四种方法:设定指定的任务task在指定的时间firstTime开始进行重复的周期性执行,周期时间为period
         *  schedule(TimerTask task, Date firstTime, long period) 
         *  scheduleAtFixedRate(TimerTask task,Date firstTime,long period)
         *  period 单位为毫秒
         */
        public static void timer4() {  
            Calendar calendar = Calendar.getInstance();  
            calendar.set(Calendar.HOUR_OF_DAY, 12); // 控制时  
            calendar.set(Calendar.MINUTE, 0);       // 控制分  
            calendar.set(Calendar.SECOND, 0);       // 控制秒  
      
            Date time = calendar.getTime();         // 得出执行任务的时间,此处为今天的12:00:00  
            Timer timer = new Timer();  
            timer.schedule(new TimerTask() {  
                public void run() {  
                	System.out.println(new Date() +"\t"+"---指定要执行任务---");  
                }  
            }, time, 1000);
        }  
        
        /**
         * schedule和scheduleAtFixedRate方法的区别:
         * (1)schedule方法:如果第一次执行时间被delay了,随后的执行时间按照上一次实际执行完成的时间点进行计算,即:下一次的执行时间点=上一次程序执行完成的时间点+间隔时间 
         * (2)scheduleAtFixedRate方法:如果第一次执行时间被delay了,随后的执行时间按照上一次开始的时间点进行计算,即:下一次的执行时间点=上一次程序开始执行的时间点+间隔时间,
         * 并且前一个任务的执行时间大于间隔时间,就会与当前任务重叠,TimerTask中的执行体需要考虑线程同步 
         */
        
    }
    

    Timer的缺陷:

    (1)由于执行任务的线程只有一个,所以如果某个任务的执行时间过长,那么将破坏其他任务的定时精确性。如一个任务每1秒执行一次,而另一个任务执行一次需要5秒,那么如果是固定速率的任务,那么会在5秒这个任务执行完成后连续执行5次,而固定延迟的任务将丢失4次执行。

    (2)如果执行某个任务过程中抛出了异常,那么执行线程将会终止,导致Timer中的其他任务也不能再执行。

    (3)Timer使用的是绝对时间,即是某个时间点,所以它执行依赖系统的时间,如果系统时间修改了的话,将导致任务可能不会被执行。

    由于Timer存在上面说的这些缺陷,在JDK1.5中,我们可以使用ScheduledThreadPoolExecutor来代替它,使用Executors.newScheduledThreadPool工厂方法或使用ScheduledThreadPoolExecutor的构造函数来创建定时任务,它是基于线程池的实现,不会存在Timer存在的上述问题,当线程数量为1时,它相当于Timer。

    2、JDK自带的ScheduledThreadPoolExecutor来实现
     /**
         * ScheduledThreadPoolExecutor 有两种创建方式:第一种,通过Executors创建;第二种:通过构造方法
         * scheduleAtFixedRate(Runnable command, long initialDelay, long period,TimeUnit unit)
         * initialDelay 首次执行任务的延迟时间
         * period  每次执行任务的间隔时间
         * unit   执行的时间间隔数值单位
         * 间隔单位毫秒:TimeUnit.MILLISECONDS 
         * 间隔单位秒:TimeUnit.SECONDS 
         * 间隔单位分钟:TimeUnit.MINUTES 
         * 间隔单位小时:TimeUnit.HOURS 
         * 间隔单位天:TimeUnit.DAYS
         */
        public static void timer5(){
        	ScheduledThreadPoolExecutor scheduled = (ScheduledThreadPoolExecutor)Executors.newScheduledThreadPool(10);
    //    	ScheduledThreadPoolExecutor  scheduled = new ScheduledThreadPoolExecutor(10);
        	scheduled.scheduleAtFixedRate(new Runnable() {
                 @Override
                 public void run() {
                     System.out.println(new Date());
                 }
             }, 0, 40, TimeUnit.MILLISECONDS);
        }
    3、Quartz整合spring实现

    (1)增加maven依赖

    <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-web</artifactId>
       <version>3.2.9.RELEASE</version>	
    </dependency>
    <dependency>
       <groupId>org.quartz-scheduler</groupId>
       <artifactId>quartz</artifactId>
       <version>1.8.5</version>
    </dependency>

    (2)增加定时业务类

    package quartz;
    
    import java.util.Date;
    
    import javax.annotation.PostConstruct;
    
    import org.springframework.stereotype.Service;
    
    @Service("ExpireJobTaskService")
    public class ExpireJobTask {
    	
    	public void reload() {
    		load();
    	}
    	
    	@PostConstruct
    	public void load(){
    		System.out.println(new Date()+"\t"+"执行定时任务");
    	}
    
    }

    (3)增加spring配置

    <?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:aop="http://www.springframework.org/schema/aop"
    	xmlns:context="http://www.springframework.org/schema/context"
    	xmlns:task="http://www.springframework.org/schema/task"
    	xsi:schemaLocation="
          http://www.springframework.org/schema/context classpath:org/springframework/context/config/spring-context-3.0.xsd
          http://www.springframework.org/schema/beans classpath:org/springframework/beans/factory/xml/spring-beans-3.0.xsd
          http://www.springframework.org/schema/aop classpath:org/springframework/aop/config/spring-aop-3.0.xsd">
     
    	
    	<!-- 扫描指定package下所有组件注解并注册为Spring Beans -->
    	<context:component-scan base-package="quartz" />
    	
    	
    	<!-- 调度业务 -->
    	<bean id="ExpireJobTaskJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    		<property name="targetObject" ref="ExpireJobTaskService" />
    		<property name="targetMethod" value="reload" />
    	</bean>
    	<!-- 调度触发器 -->
    	<bean id="ExpireJobTaskJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
    		<property name="jobDetail" ref="ExpireJobTaskJobDetail" />
    		<property name="cronExpression" value="0 0/1 * * * ?" />
    	</bean> 
    	
    	<!-- 设置调度    triggers属性中,我们可以增加多个触发器。 -->
    	<bean name="startQuertz"  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    		<property name="triggers">
    			<list>
    				<ref bean="ExpireJobTaskJobTrigger" />
    			</list>
    		</property>
    	</bean>
    	
    	
    </beans>
    4、spring定时任务实现:

    spring定时任务比较简单,只需要在maven依赖中引入相关jar包,使用注解进行配置。

    示例:

    package quartz;
    
    import java.util.Date;
    
    import javax.annotation.PostConstruct;
    
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.stereotype.Service;
    
    @Service
    public class ExpireJobTask {
    	
    	@PostConstruct
    	public void reload() {
    		load();
    	}
    	
    	@Scheduled(cron = "0 0/1 0 * * ?")
    	public void load(){
    		System.out.println(new Date()+"\t"+"执行定时任务");
    	}
    
    }
    







    展开全文
  • Java定时任务Schedule实现的4种方式

    万次阅读 多人点赞 2019-02-28 08:38:20
    java实现定时任务 Schedule https://blog.csdn.net/java_2017_csdn/article/details/78060204 2017年09月22日 10:30:52Java_2017_csdn阅读数:3306 java实现定时任务 Schedule 标签:java实现定时任务 Schedule...

    java实现定时任务 Schedule

    https://blog.csdn.net/java_2017_csdn/article/details/78060204

    2017年09月22日 10:30:52 Java_2017_csdn 阅读数:3306

    java实现定时任务 Schedule

    标签: java实现定时任务 Schedulejava实现定时任务java Schedule

    2016-06-07 11:56 16864人阅读 评论(0) 收藏 举报

    分类:

    java(107) 

    目录(?)[+]

    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 定时任务几种实现方式

    千次阅读 2016-10-25 19:53:27
    在一个项目中往往需要定时或者在特定的时间执行一些任务
  • Java实现定时任务几种方式

    千次阅读 2015-09-19 01:34:08
    Thread 最普通方式(不推荐) Runnable runnable = new Runnable() { public void run() { SystemClock.sleep(8000); System.out.println("thread"); } }; Th...
  • public class ImmediateJob implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { } }
  • Java 实现定时任务的四种方式

    万次阅读 2016-11-03 18:25:39
    Java 实现定时任务的四种方式
  • java Spring 定时任务几种实现

    千次阅读 2015-08-08 10:06:43
    近日项目开发中需要执行一些定时任务,比如需要在每天凌晨时候,分析一次前一天的日志信息,借此机会整理了一下定时任务几种实现方式,由于项目采用spring框架,所以我都将结合 spring框架来介绍。 一.分类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,962
精华内容 21,584
关键字:

java定时任务实现的几种方式

java 订阅