Java-定时器

Java-定时器

@Scheduled注解

@Scheduled 标记要调度的方法的注解。必须指定 cron，fixedDelay或 fixedRate属性之一。该注解共有8个参数，以下对这个8个参数进行记录。@Scheduled注解是最简单的方式，只需要启用定时器，在方法上添加注解即可。

1.在spring配置中加入：
xmls添加

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

注入

<!-- 启用注解定时器 -->
    <task:annotation-driven />

2.编写定时任务并添加@Scheduled 注解

配置完整格式为： [秒] [分] [小时] [日] [月] [周] [年]
其中每个元素可以是一个值(如6),
一个连续区间(9-12),
一个间隔时间(8-18/4)(/表示每隔4小时),
一个列表(1,3,5),
通配符。由于"月份中的日期"和"星期中的日期"这两个元素互斥的,必须要对其中一个设置?.

@Scheduled(cron = "0 0 * * * ? ")
    public void myTask(){
           //定时任务
           //要运行的任务代码
}

例子
cron

	@Scheduled(cron = "*/5 * * * * ?") //每五秒钟执行一次
    public void scheduledDemo() {
        System.out.println("test"+new Date());
        //要运行的任务代码
    }

fixedDelay
fixedDelay 从上次调用结束到下一次调用之间的固定时间（以毫秒为单位）

	@Scheduled(fixedDelay = 5000) //上次调用结束后5秒再执行
    public void scheduledDemo() {
        System.out.println("test"+new Date());
        //要运行的任务代码
    }

fixedDelayString与fixedDelay 意思相同，只是使用字符串的形式。唯一不同的是支持占位符

@Scheduled(fixedDelayString = "5000")   
//占位符的使用(配置文件中有配置：time.fixedDelay=5000)：
@Scheduled(fixedDelayString = "${time.fixedDelay}")
 //上次调用结束后5秒再执行

fixedRate
fixedRate 两次调用之间固定的毫秒数

	@Scheduled(fixedRate = 5000)
	//上次开始无论是否结束5秒钟之后会再次执行
    public void scheduledDemo() {
        System.out.println("test"+new Date());
        //要运行的任务代码
    }

fixedRateString与 fixedRate 意思相同，只是使用字符串的形式。唯一不同的是支持占位符。

@Scheduled(fixedRateString = "5000")
//上次开始无论是否结束5秒钟之后会再次执行

2.quartz

1.Job，这是一个接口，并且只有一个void execute(JobExecutionContext context) throws JobExecutionException的方法。这个方法定义了需要调度的方法，开发者在使用Quartz并定义调度任务时候，需要实现这个接口并且重写此方法。

2.JobDetail，看名字也知道这是Job的实现类，当Quartz执行Job时，它会接受JobDetail这个实现类，通过newInstance()的反射调用机制来实例化一个Job，也就是说，在实例化Job时，需要有一个返回值来接受实例化的Job和一些静态信息。

3.Trigger，这是一个类，包括两个子类，主要是触发Job执行的时间触发规则，主要有SimpleTrigger和CronTrigger两个子类；当仅需要触发一次或者以固定检核周期性执行时，SimpleTrigger一定是最合适的选择，当如果要执行复杂的调度规则时，则可以使用CronTrigger。

4.Scheduler，代表一个Quartz的独立运行容器，Trigger和JobDetail可以注册到Scheduler中，二者在Scheduler中有各自的组件、名称和组

1.引入依赖

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

2.新建类，一个HelloJob类实现Job接口中的execute方法，编写具体的业务逻辑。

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

import java.text.SimpleDateFormat;
import java.util.Date;

public class HelloJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //编写具体的业务逻辑
	   //要运行的任务代码
        Date date=new Date();
        SimpleDateFormat sf=new SimpleDateFormat("yy-mm-dd HH:mm:ss");
        System.out.println("Current execu time is "+sf.format(date));
    }
}

3.创建一个HelloSchedule类，创建JobDetail实例，引入HelloJob类文件，然后创建trigger实例，定义job完成的方式（次数，时间等。）

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.text.SimpleDateFormat;
import java.util.Date;

public class HelloSchedule {
    public static void main(String[] args) throws SchedulerException{
        //创建一个JobDetail实例，引入该实例
        JobDetail jobDetail= JobBuilder.newJob(HelloJob.class)
                .withIdentity("myJob","group1").build();
        //创建一个Trigger实例，定义该job立即执行，每隔两秒钟重复执行一次
        //这里我们把trigger和jobDetail定在同一组，其实不是同一组的
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("myTrigger","group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder//SimpleScheduleBuilder是简单调用触发器，它只能指定触发的间隔时间和执行次数；
                        .simpleSchedule()//创建一个SimpleScheduleBuilder
                        .withIntervalInSeconds(20)//指定一个重复间隔,以秒为单位。
                        .withRepeatCount(10))//指定反复的次数
                .build();//注意build是的主语是谁
        //创建trigger实例
        SchedulerFactory sf=new StdSchedulerFactory();
        Scheduler scheduler=sf.getScheduler();
        scheduler.start();
       //打印当前时间
        Date date=new Date();
        SimpleDateFormat sf1=new SimpleDateFormat("yy-mm-dd HH:mm:ss");
        System.out.println("Current time is "+sf1.format(date));
        scheduler.scheduleJob(jobDetail,trigger);
    }
}

3.Timer

使用Timer的schedule，schedule有3个参数：
schedule(TimerTask task, long delay, long period)
task:第一个为定时任务，根据业务需要重写TimerTask的run方法即可；
delay:第二个为延时启动，单位毫秒；
period:第三个位多久运行一次，单位毫秒；

new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                try {
                     //要运行的任务代码
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },1000,2000);

Timer timer = new Timer();
timer.schedule(new TimerTask() {
        public void run() {
              //要运行的任务代码
        }
}, 1000 , 2000);

4.使用线程控制

使用线程来控制就更灵活一些，可以根据自己的需要判断什么时候运行，什么时候停止

public class Task1 {
    public static void main(String[] args) {
        // run in a second
        // 每一秒钟执行一次
        final long timeInterval = 1000;
        Runnable runnable = new Runnable() {
            public void run() {
                while (true) {
                    // ------- 要运行的任务代码
                    try {
                        // sleep()：同步延迟数据，并且会阻塞线程
                        Thread.sleep(timeInterval);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        //创建定时器
        Thread thread = new Thread(runnable);
        //开始执行
        thread.start();
    }
}