守时/方案功能在Java运用的各个领域都运用得十分多，比方说Web层面，或许一个项目要守时收集话单、守时更新某些缓存、守时整理一批不活泼用户等等。守时方案使命功能在Java中首要运用的便是TImer目标，它在内部运用多线程办法进行处理，所以它和多线程技能相关仍是相当大的。
一、相关常识学习
1、 Java守时器TImer
用于Java线程里指守时刻或周期运转使命。TImer是线程安全的，但不供给实时性（real-TIme）确保。
schdule办法：
schedule（TimerTask task， long delay）
以当时时刻为基准，推迟指定的毫秒后履行一次TimerTask使命。
schedule（TimerTask task， Date time）
在指定的日期履行一次TimerTask使命。
假如日期time早于当时时刻，则马上履行。
schedule（TimerTask task， long delay， long period）
以当时时刻为基准，推迟指定的毫秒后，再按指定的时刻距离地无限次数的履行TimerTask使命。
schedule（TimerTask task， Date firstTime， long period）
在指定的日期之后，按指定的时刻距离地无限次数的履行TimerTask使命。
scheduleAtFixedRate办法：
scheduleAtFixedRate（TimerTask task， long delay， long period）
以当时时刻为基准，推迟指定的毫秒后，再按指定的时刻距离周期性地无限次数的履行TimerTask使命。
假如日期firstTime早于当时时刻，则马上履行，且不履行在时刻差内的使命。
scheduleAtFixedRate（TimerTask task， Date firstTime， long period）
在指定的日期之后，按指定的时刻距离周期性地无限次数的履行TimerTask使命。
假如日期firstTime早于当时时刻，则当即履行，并弥补性的履行在时刻差内的使命。
2、 Java多线程学习
在java中要想完结多线程，有两种手法，一种是持续Thread类，别的一种是完结Runable接口。
java多线程之承继Thread类创立线程类的过程如下：
1.创立Thread类的子类，并重写run（）办法。
2.创立Thread子类的实例即线程目标3.调用线程目标的start（）办法
3.调用线程目标的start（）办法
Thread类有以下常用结构办法：
1.Thread（）
2.Thread（String name）
3.Thread（Runnable r）
4.Thread（Runnable r，String name）
运用Thread类创立线程类，多个线程之间无法同享线程类的实例变量。
完结Runnable接口比承继Thread类所具有的优势：
1.合适多个相同的程序代码的线程去处理同一个资源
2.能够防止java中的单承继的约束
3.添加程序的健壮性，代码能够被多个线程同享，代码和数据独立
4.线程池只能放入完结Runable或callable类线程，不能直接放入承继Thread的类
二、练习
1、完结一个java application运用程序，运用守时器编程，在实时显现当时时刻，每1秒时钟内容更新一次。
java程序（test1.java）
import java.util.*;//导入java.util包下的一切类
public class test1 {
private static Timer timer = new Timer（）;//创立一个Timer类的实例
public static class MyTask extends TimerTask {//创立一个MyTask类承继于父类TimerTask
@Override
public void run（） {
System.out.println（“Now Time： ” + new Date（）.toString（））;//输出当时时刻信息
}
}
public static void main（String［］ args） {
MyTask task = new MyTask（）;
timer.schedule（task， 0， 1000）;//以当时基准时刻推迟0秒后履行一次，今后按指定距离时刻1秒无限次数的履行。
}
}
运转效果图
2、完结一个java application运用程序，在运用程序主进程中新开一个线程，此线程进行死循环，每1秒被激活一次，激活时即在输出显现当时时刻。
java程序（test2.java）
import java.util.*;//导入java.util包下的一切类
public class test2 {
public static void main（String［］ args） {
FirstThread a=new FirstThread（）;//创立一个FirstThread类目标
a.start（）;//敞开线程
}
}
class FirstThread extends Thread{//创立Thread子类
public void run（）{
try{//反常处理
while （true）{//界说死循环
Thread.sleep（1000）;//线程每隔1秒激活一次
System.out.println（“Now Time： ” + new Date（）.toString（））;//输出当时时刻信息
}
}
catch（InterruptedException e）{
}
}
}
运转效果图
3、完结一个java application运用程序，此运用程序公共类有一个double型类特点（变量）x，初始值为0；在运用程序主进程中新开两个线程，这两个线程都进行死循环；第1个线程每隔300ms激活一次，令类特点x自加1.0并输出显现；第2个线程每隔400ms激活一次，令类特点x自加0.1并输出显现。
java程序（test3.java）
public class test3{
static double x=0; //界说一个double型变量并赋值
public static void main（String［］ args）{
new Thread（new OneThread（））.start（）;//敞开线程
new Thread（new TwoThread（））.start（）;//敞开线程
}
public static class OneThread implements Runnable{//经过完结Runnable接口来创立线程类
public void run（）{
while （true）{//界说死循环
try{//反常处理
Thread.sleep（300）;//线程每隔300ms激活一次
x=x+1;
System.out.println（“one：”+x）;//输出x
}
catch（InterruptedException e）{
}
}
}
}
public static class TwoThread implements Runnable{//经过完结Runnable接口来创立线程类
public void run（）{
while （true）{//界说死循环
try{//反常处理
Thread.sleep（400）;//线程每隔400ms激活一次
x=x+0.1;
System.out.println（“two：”+x）;//输出x
}
catch（InterruptedException e）{
}
}
}
}
}
运转效果图
java 守时使命多线程处理
@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer， AsyncConfigurer{
/** 异步处理 */
public void configureTasks（ScheduledTaskRegistrar taskRegistrar）{
TaskScheduler taskScheduler = taskScheduler（）;
taskRegistrar.setTaskScheduler（taskScheduler）;
}
/** 守时使命多线程处理 */
@Bean（destroyMethod = “shutdown”）
public ThreadPoolTaskScheduler taskScheduler（）{
ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler（）;
scheduler.setPoolSize（20）;
scheduler.setThreadNamePrefix（“task-”）;
scheduler.setAwaitTerminationSeconds（60）;
scheduler.setWaitForTasksToCompleteOnShutdown（true）;
return scheduler;
}
/** 异步处理 */
public Executor getAsyncExecutor（）{
Executor executor = taskScheduler（）;
return executor;
}
/** 异步处理 反常 */
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler（）{
return new SimpleAsyncUncaughtExceptionHandler（）;
}
}
