java时间调度器（定时任务）

package com.ssh.quartz;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class TaskTest {

	public static void main(String[] args)throws Exception {
		// testTimer();

//		testSchedule();
		
		testQuartz();
	}

	public static void testTimer() {
		Timer t = new Timer();
		t.scheduleAtFixedRate(new Task(), 0, 1000 * 2);
	}

	public static void testSchedule() {
		ScheduledExecutorService execService = Executors
				.newScheduledThreadPool(3);
		execService.scheduleAtFixedRate(new ScheduleTask(), 0, 2,
				TimeUnit.SECONDS);
	}

	public static void testQuartz() throws Exception {
		SchedulerFactory schedFact = new StdSchedulerFactory();
		Scheduler sched = schedFact.getScheduler();
		sched.start();
		JobDetail job = JobBuilder.newJob(HelloJob.class)
				.withIdentity("myJob", "group1")
				.usingJobData("jobSays", "hello world!")
				.usingJobData("myFloatValue", 3.141f).build();
		Trigger trigger = TriggerBuilder
				.newTrigger()
				.withIdentity("myTrigger", "group1")
				.startNow()
				.withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
				.build();
		sched.scheduleJob(job, trigger);
	}
}


class ScheduleTask implements Runnable {

	public void run() {
		System.out.println("test shedule");
	}

}

class Task extends TimerTask {

	@Override
	public void run() {
		System.out.println("test timer");
	}

}

 

package com.ssh.quartz;

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

public class HelloJob implements Job{

	public void execute(JobExecutionContext context) throws JobExecutionException {
		System.out.println("test quartz");
	}

	
}

 三者的区别：

Timer是单线程的，如果其中一个任务报错了，那么所有的任务都将失败，且是不可恢复的。

ScheduledExecutorService是一个线程池在跑所有的任务，如果一个任务报错了，不会影响到其他的任务。但这个报错的任务是无法恢复的。

quartz：也是多线程在跑所有的任务，每个任务的报错都不会影响到其他的任务，并且这个报错的任务是自动可恢复的。