java定时器和多线程

定时/计划功能在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（）;

}

}