java定时任务调度

spring Schedule

默认单线程

1. pom.xml文件中添加依赖
   
2. 创建一个可以被扫描到的类，给其中的方法加上@Scheduled注解
   
3. 启动类中添加@EnableScheduled注解
   

这样就可以开始定时任务的启动了。
spring schedule中@Scheduled注解有如下参数
//第一次调用执行完后再间隔指定时间（1000毫秒）再次执行
@Scheduled(fixedDelayString=“1000”)
@Scheduled(fixedDelay=1000)
//每隔指定时间（1000毫秒）执行一次，不管第一个是否执行完
@Scheduled(fixedRate=1000)
//initialDelay初始化延迟时长3000毫秒，只初始化一次，不设置则是启动就执行
@Scheduled(initialDelay=3000,fixedDelay=1000)
@Scheduled(cron="*/3 23 13 * * ?")
->Cron表达式

配置多线程

添加配置类

@Configuration
public class ConfigSchedule implements SchedulingConfigurer {

  public void configureTasks(ScheduledTaskRegistrar task) {
 	task.setScheduler(Executors.newScheduledThreadPool(10));
  }
	
}

spring + Quartz

1. 首先上配置jar

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

2. 实现Job接口，编写具体任务类

public class RealJob implements Job{

	private static final Logger log = LoggerFactory
				.getLogger(RealJob.class);
	public void execute(JobExecutionContext context) 
							throws JobExecutionException {
        log.info("任务1");
	}
	
}

3. 创建Job类的管理类

@Component
public class SchedulerManager {

	public static Logger log=LoggerFactory
			.getLogger(SchedulerManager.class);
	
	@Autowired
	private Scheduler scheduler;
	private String name="myjob";
	private String group="mygroup";
	public SchedulerManager setName(String name){
		this.name=name;
		return this;
	}
	public SchedulerManager setgroup(String group){
		this.group=group;
		return this;
	}
	public void startJob(Class<? extends Job> cl,String cron)
				throws SchedulerException{
		//通过JobBuilder构建JobDetail实例，
		//JobDetail 是具体Job实例（RealJob）
		JobDetail jobDetail=JobBuilder.newJob(cl)
				.withIdentity(name, group).build();
		//创建触发器的时间
		CronScheduleBuilder cronSchedule=CronScheduleBuilder
				.cronSchedule(cron);
		//通过Trigger创建触发器
		Trigger trigger=TriggerBuilder.newTrigger()
				.withIdentity(name, group)
				.withSchedule(cronSchedule).build();
		scheduler.scheduleJob(jobDetail, trigger);
		scheduler.start();
	}
}

4. 在spring中通过初始化任务调度执行定时任务

@Configuration
@Repository
public class StartJob implements 
				ApplicationListener<ContextRefreshedEvent> {
	private static Logger log=LoggerFactory
				.getLogger(StartJob.class);
	@Autowired
	private SchedulerManager scheduleManager;

	public void onApplicationEvent(
				ContextRefreshedEvent event) {
		try {
			scheduleManager.setName("name1")
			.setgroup("group1")
			.startJob(RealJob.class, "1-10/3 * * * * ?");;
			log.info("定时任务启动。。。。。。。。。。。。");
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}
	@Bean
	public Scheduler getScheduler() throws 
				SchedulerException{
		SchedulerFactory scheduler=new StdSchedulerFactory();
		return scheduler.getScheduler();
	}
}

5. 执行启动类Application

@SpringBootApplication
public class Application {

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}

}

github：https://github.com/hc1609/schedule.git

行路不仅仅在于快慢，还在于是否能够持续；前进不仅仅在于速度，更在于能否保持正确方向。