聊聊定时任务
定时任务，顾名思义就是，定时去完成某项任务，例如指定某个时间点去做某件事情或者是指定一定的时间间隔去做某些事情。使用定时任务就是一种对生产力的解放，如果没有定时任务的话，对于以上的需求，可能我们需要一个人力不断的去进行操作，而且无法保证你的时间点是准确的，你的时间间隔总是相同的。因此，定时任务就是在后台启动一个线程定期定时的为你去执行相同的事情。在本篇文章中我们主要叨叨一下以一定的时间间隔去执行某一项任务。而定时任务都是基于线程来实现的，所以，在看本篇文章的时候，你应该了解一下线程的相关知识。
说说他的用处
再谈定时任务的用处时，如果还是说一些理论化的东西，那么就没有意义了。我们以一种需求驱动的方式来进行。我简单的提出几个需求就可以大致的理解了他的作用。
1、服务后台跑一个定时任务来进行非实时计算，清除临时数据、文件等。
2、每一个月去执行一次对数据库中的数据进行切割。
3、没五分钟统计一次当前系统的负载量
......
看看他的实现
方案一：使用java.lang.Thread
实现代码：
package haiyang.yu.timer;
import java.util.Date;
/**
* Created on 2018-04-20 13:09
* <p>Title: haiyang.yu.timer</p>
* <p>Description: </p>
*
* @author <a href="mailto:991138518@qq.com">yuhaiyang</a>
* @version 1.0
*/
public class TimedTask {
private static void useThreadImplTimedTask(){
Runnable runnable = new Runnable() {
@Override
public void run() {
while (true) {
System.out.println("Local Time is " + new Date().toString());
try {
//时间间隔，单位是毫秒
Thread.sleep(1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
Thread thread = new Thread(runnable);
thread.start();
}
public static void main(String[] args) {
useThreadImplTimedTask();
}
}
实现原理：
这种实现方案是使用的最普遍的，而且也是最不推荐的。不推荐，为什么使用的还那么多呢？因为简单。
在不影响其他任务的实现时，我们只需要创建一个单独的线程，在线程中无限循环的去执行我们任务即可。
时间间隔使用Thread.sleep(interval)就好了，让他做完这件事情就歇一会，再做下一次任务。
以上的实现中我们在useThreadImplTimedTask()方法中实现了java.lang.Runnable接口，并实现他的run()方法，这就实现了对线程的创建。但是对于线程来说，他的执行是顺序的，当我执行完任务中的所有代码后，我们的线程会gc掉的，怎么实现让他始终不会停下来呢？我们只需要在run方法中使用一个永远为真的循环就解决了啊。因此我们使用while(true)来实现一个‘永不死亡’的线程。此时，我们运行这段代码时他就会无限的执行下去。但是此时，他是不受控制的，他是很自私的，不会停下来等你的。要想让他停下来，你就要明确的并且强制的告诉他，干完了，你就先休息一会，休息完了你在做下一次。
优点缺点：
1、编码方式是不建议的行为
2、启动和取消是不可控的。
3、不是线程安全的
方案二：使用java.util.Timer
敲敲实现代码：
package haiyang.yu.timer;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
/**
* Created on 2018-04-20 13:09
* <p>Title: haiyang.yu.timer</p>
* <p>Description: </p>
*
* @author <a href="mailto:991138518@qq.com">yuhaiyang</a>
* @version 1.0
*/
public class TimedTask {
private static void useTimerImplTimedTask(){
// 第一个参数是任务，第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间，时间单位是毫秒
new Timer().scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println("Local Time is " + new Date().toString());
}
},0L,1000L);
}
public static void main(String[] args) {
useTimerImplTimedTask();
}
}
说说Timer：
Timer是用于管理在后台执行的延迟任务或周期性任务，其中的任务使用java.util.TimerTask表示。任务的执行方式有两种：
- 按固定速率执行：即scheduleAtFixedRate的两个重载方法
- 按固定延迟执行：即schedule的4个重载方法
我们要实现一个定时任务，只需要实现TimerTask的run方法即可。每一个任务都有下一次执行时间nextExecutionTime（毫秒），如果是周期性的任务，那么每次执行都会更新这个时间为下一次的执行时间，当nextExecutionTime小于当前时间时，都会执行它。
Timer的具体使用方法也是非常简单，只需要创建一个实例，在通过实例调用一些任务的方法即可。
package haiyang.yu.json;
import java.util.Timer;
import java.util.TimerTask;
/**
* Created on 2018-04-20 13:09
* <p>Title: haiyang.yu.timer</p>
*
* @author <a href="mailto:991138518@qq.com">yuhaiyang</a>
* @version 1.0
*/
public class TimedTask {
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
//do something
}
},2000);
}
}
上面这个定时任务表示在2秒后开始执行，只执行一次。如果想要执行周期性任务，只需要添加schedule的第三个参数period。
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
//do something
System.out.println(new Date().toString());
}
},2000, 1000);
}
表示2秒后开始执行，然后每隔1秒执行一次。
任务执行周期可为正和负：
- 正数：表示按照固定的速率调度执行，比如执行周期是每5秒执行一次，如上一次执行时间是20:51:30，那么下一次执行时间就为20:51:35，如果由于执行其他任务的时间超过5秒，比如用了15秒，那么这有可能会导致这种任务不能够在指定的时间执行，这就破坏了任务执行的速率（rate），但是会在后面连续执行3次。
- 负数：表示按照固定的延迟来调度执行，比如执行周期是每5秒执行一次，在正常情况下，如它的执行时间是20:51:30，但是由于执行其他任务时间花了8秒秒，即执行到当前任务时是20:51:38，那么它的下一次执行时间将向后推迟，即20:51:43。
说说实现原理：
对于每一个Timer，后台只使用一个线程来执行所有的任务。而所有的任务都保存到一个任务队列java.util.TaskQueue中，它是Timer的一个内部类，这是一个优先级队列，使用的算法是最小二叉堆（binary min heap）。
当任务队列中所有的任务都执行完后，即没有一次性执行的任务，也没有周期性的任务，那么Timer的后台线程将优雅地终止，并成为垃圾回收的对象。但是这可能要很长时间后才发生。这里虽说是要终止线程，但是时间不确定，有可能永远不会终止，在执行完任务后线程处于WAITING状态，直到虚拟机退出。
一个TimerTask有四种状态：
- VIRGIN：新创建的任务的状态，表示还未安排执行
- SCHEDULED：已安排执行，对于非周期性的任务来说，表示还未执行，当把任务添加到任务执行队列时的状态，即调用Timer.schedule时
- EXECUTED：表示非周期性任务已经执行或正在执行中，并且还未被取消
- CANCELLED：表示任务已经取消，当调用cancel方法后即为该状态，该状态的任务会在每次执行时被移出队列
优点：
- 于第一种方式相比，优势 1>当启动和去取消任务时可以控制 2>第一次执行任务时可以指定你想要的delay时间
- 在实现时，Timer类可以调度任务，TimerTask则是通过在run()方法里实现具体任务。 Timer实例可以调度多任务，它是线程安全的。
缺点：
由于Timer执行任务的线程只有一个，所以如果某个任务的执行时间过长，那么将破坏其他任务的定时精确性。如一个任务每1秒执行一次，而另一个任务执行一次需要5秒，那么如果是固定速率的任务，那么会在5秒这个任务执行完成后连续执行5次，而固定延迟的任务将丢失4次执行。
如果执行某个任务过程中抛出了异常，那么执行线程将会终止，导致Timer中的其他任务也不能再执行。
Timer使用的是绝对时间，即是某个时间点，所以它执行依赖系统的时间，如果系统时间修改了的话，将导致任务可能不会被执行。
方案三：使用java.util.concurrent.ScheduledExecutorService
由于Timer存在上面说的这些缺陷，在Java5之后，并发线程这块发生了根本的变化，最重要的莫过于新的启动、调度、管理线程的一大堆API了。定时任务在1.5之前是使用 Timer 来实现的，但由于 Timer 有一些问题：
Timer对调度的支持是基于绝对时间,而不是相对时间的，由此任务对系统时钟的改变是敏感的;ScheduledThreadExecutor只支持相对时间。Timer的另一个问题在于，如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以TimerTask抛出的未检查的异常会终止timer线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被安排但尚未执行的TimerTask永远不会再执行了，新的任务也不能被调度了。
实现代码：
package haiyang.yu.timer;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* Created on 2018-04-20 13:09
* <p>Title: haiyang.yu.timer</p>
* <p>Description: </p>
*
* @author <a href="mailto:991138518@qq.com">yuhaiyang</a>
* @version 1.0
*/
public class TimedTask {
private static void userScheduledExecutorServiceImplTiemdTask(){
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Local Time is " + new Date().toString());
}
};
ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
// 第一个参数是任务，第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间,第四个参数是时间单位
service.scheduleAtFixedRate(runnable, 0L, 1L, TimeUnit.SECONDS);
}
public static void main(String[] args) {
userScheduledExecutorServiceImplTiemdTask();
}
}
说说运行原理：
优点缺点：
方案四：java.util.concurrent.ScheduledThreadPoolExecutor结合org.apache.commons.lang3.concurrent.BasicThreadFactory
由于Timer存在单线程的缺陷，在JDK1.5中，我们可以使用ScheduledThreadPoolExecutor来代替它，使用Executors.newScheduledThreadPool工厂方法或使用ScheduledThreadPoolExecutor的构造函数来创建定时任务，它是基于线程池的实现，不会存在Timer存在的上述问题，当线程数量为1时，它相当于Timer。
实现代码：
package haiyang.yu.timer;
import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import java.util.Date;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
/**
* Created on 2018-04-20 13:09
* <p>Title: haiyang.yu.timer</p>
* <p>
使用这种方案，需要引入common-lang3的jar包
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.6</version>
</dependency>
* </p>
*
* @author <a href="mailto:991138518@qq.com">yuhaiyang</a>
* @version 1.0
*/
public class TimedTask {
private static void useScheduledThreadPoolExecutorImplTimedTask(){
ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(
1, new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(false).build());
// 第一个参数是任务，第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间,第四个参数是时间单位
scheduledThreadPoolExecutor.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("Local Time is " + new Date().toString());
}
}, 0L, 1L, TimeUnit.SECONDS);
}
public static void main(String[] args) {
useScheduledThreadPoolExecutorImplTimedTask();
}
}
实现原理：
瞅瞅优点缺点：
方案五：使用quartz
唠唠他们的区别
扯扯这个作者
老老实实做人，踏踏实实工作，疯疯癫癫生活，认认真真胡闹。
聊聊谈谈说说讲讲看看唠唠扯扯
