java中Timer定时器的使用和启动方式

目录
  • Timer定时器的使用和启动
    • 1.概述
    • 2.应用场景
    • 3.使用方法
    • 4.启动方法
  • java的几种定时器小结
    • 1.@Scheduled注解
    • 2.quartz
    • 3.使用Timer
    • 4.使用线程控制

Timer定时器的使用和启动

1.概述

定时计划任务功能在Java中主要使用的就是Timer对象,它在内部使用多线程的方式进行处理,所以它和多线程技术还是有非常大的关联的。在JDK中Timer类主要负责计划任务的功能,也就是在指定的时间开始执行某一个任务,但封装任务的类却是TimerTask类。

2.应用场景

我们使用timer的时候,一般有4种情况:

  • 指定时间执行
  • 指定时间执行后间隔指定时间重复执行
  • 启动任务之后多久执行
  • 启动任务后多久执行,执行之后指定间隔多久重复执行

3.使用方法

首先要通过继承 TimerTask 类 并实现 run() 方法来自定义要执行的任务(当然也可以写成匿名内部类),

需要创建一个定时器(Timer类对象),并通过Timer.schedule(TimerTask task,Date time) 方法执行时间运行任务

具体代码如下:

package timerdemo;
import java.util.Timer;
import java.util.TimerTask;
public class TimerDemo {
	public static void main(String[] args) {
		timerTest();
	}

	public static void timerTest(){
		//创建一个定时器
		Timer timer = new Timer();
		//schedule方法是执行时间定时任务的方法
		timer.schedule(new TimerTask() {

			//run方法就是具体需要定时执行的任务
			@Override
			public void run() {
				System.out.println("timer测试!!!");
			}
		}, 1000, 10000);
	}
}

这里的 schedule方法有4个,分别对应上面说的四种情况:

4.启动方法

1.在jar工程下启动

把jar工程打成jar包,通过java -jar timer.jar 运行

2.这web工程下启动

spring中我们可以通过实现接口ApplicationListener,并重写public void onApplicationEvent(ApplicationEvent event) {}可以在容器初始话的时候执行这个方法

下面展示下web工程下每天00:00执行任务的代码:

@Component
public class SystemInitListener implements ApplicationListener<ContextRefreshedEvent> {
	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {

		//创建定时器
		Timer timer = new Timer();
		Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE,1);
        calendar.set(calendar.get(Calendar.YEAR),calendar.get(Calendar.MONTH),calendar.get(Calendar.DATE),0,0,0);
        long timeInterval = 24 * 60 * 60 * 1000;
        timer.schedule(new TimerTask() {

			@Override
			public void run() {
				// 每天00:00需要做的事情
			}
		}, calendar.getTime(), timeInterval);

java的几种定时器小结

总结一下我使用过的4种类型的定时器:@Scheduled注解、quartz、new Timer().schedule、使用线程控制。

1.@Scheduled注解

@Scheduled注解是最简单的方式,只需要启用定时器,在方法上添加注解即可。

在spring配置中加入:

<!-- 启用注解定时器 -->
 <task:annotation-driven />

在要具体的方法上加入注解@Scheduled

@Scheduled(cron = "0 0 * * * ? ")
    public void myTask(){
           //定时任务......
}

2.quartz

quartz使用的是可配置的方式,将所有的定时器都配置再一个xml文件里面。

步骤如下:

1.创建一个spring的配置文件:spring-quartz.xml

2.定义工作任务的job

3.定义触发器Trigger并与job绑定

4.定义调度器,并将Trigger注册到scheduler

   <bean id="myTask" class="cn.coolwind.MyTask"/>
 <!-- 1.定义工作任务job -->
    <bean id="testJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!-- 定时器的类  -->
        <property name="targetObject" ref="myTask"></property>
        <!-- 需要定时执行的方法  -->
        <property name="targetMethod" value="test"></property>
        <property name="concurrent" value="false"></property>
    </bean>
    <!-- 2.定义触发器Trigger并与Job绑定 -->
    <bean id="testJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="testJob"/>
        <!-- 根据需要设置定时执行的时间 -->
        <property name="cronExpression" value="0 0/5 * * * ?" />
    </bean>

   <!-- 3.定义调度器,并将trigger注册进去 -->
<bean name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                 <ref local="testJobTrigger" />
            </list>
        </property>
    </bean>

最后记得将xml写入web.xml里!

    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>
    classpath:applicationContext.xml,
    classpath:log4j.xml,
                classpath:spring-quartz.xml
   </param-value>
    </init-param>

3.使用Timer

使用Timer的schedule,schedule有3个参数:

schedule(TimerTask task, long delay, long period)

第一个为定时任务,根据业务需要重写TimerTask的run方法即可;

第二个为延时启动,单位毫秒;

第三个位多久运行一次,单位毫秒;

new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                try {
                    //do Something
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        },0,5L * 60 * 1000);

4.使用线程控制

使用线程来控制就更灵活一些,可以根据自己的需要判断什么时候运行,什么时候停止,这需要对java的线程有一定的了解。

public class TaskTest {
    private static final ExecutorService pool = Executors.newFixedThreadPool(5);// 线程池
    public static final TaskTest me = new TaskTest();
    public final int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
    public static void main(String[] args) {
        me.start();
    }

    private void start() {
        pool.execute(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        for (int i = 0; i < arr.length; i++) {
                            if (1 == arr[i]) {
                                System.out.println("start!");
                                Thread.sleep(1*1000L);
                            }
                            if (6 == arr[i]) {
                                System.out.println("stop!");
                                Thread.sleep(5*1000L);
                            }
                            System.out.println(arr[i]);
                            if (9 == arr[i]) {
                                System.out.println("end!");
                                Thread.sleep(5*1000L);
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Java 中Timer和TimerTask 定时器和定时任务使用的例子

    这两个类使用起来非常方便,可以完成我们对定时器的绝大多数需求 Timer类是用来执行任务的类,它接受一个TimerTask做参数 Timer有两种执行任务的模式,最常用的是schedule,它可以以两种方式执行任务:1:在某个时间(Data),2:在某个固定的时间之后(int delay).这两种方式都可以指定任务执行的频率 TimerTest.Java: package com.cn; import java.io.IOException; import java.util.Timer; pu

  • Java定时器Timer使用方法详解

    一.概念 定时计划任务功能在Java中主要使用的就是Timer对象,它在内部使用多线程的方式进行处理,所以它和多线程技术还是有非常大的关联的.在JDK中Timer类主要负责计划任务的功能,也就是在指定的时间开始执行某一个任务,但封装任务的类却是TimerTask类. 通过继承 TimerTask 类 并实现 run() 方法来自定义要执行的任务: public class Mytask extends TimerTask { @Override public void run() { DateF

  • Java多线程定时器Timer原理及实现

    前言 定时/计划功能在Java应用的各个领域都使用得非常多,比方说Web层面,可能一个项目要定时采集话单.定时更新某些缓存.定时清理一批不活跃用户等等.定时计划任务功能在Java中主要使用的就是Timer对象,它在内部使用多线程方式进行处理,所以它和多线程技术关联还是相当大的.那和ThreadLocal一样,还是先讲原理再讲使用,Timer的实现原理不难,就简单扫一下就好了. Timer的schedule(TimeTask task, Date time)的使用 该方法的作用是在执行的日期执行一

  • Java线程Timer定时器用法详细总结

    定时/计划功能主要使用的就是Timer对象,它在内部还是使用多线程的方式进行处理,所以它和线程技术还是有非常大的关联. Timer类主要作用就是设置计划任务,但封装任务的类却是TimerTask类.TimerTask类是一个抽象类. 执行任务的时间晚于当前时间-----在未来执行的效果 import java.util.Date; import java.util.TimerTask; public class MyTask extends TimerTask{ @Override public

  • java多线程之定时器Timer的使用详解

    定时的功能我们在手机上见得比较多,比如定时清理垃圾,闹钟,等等.定时功能在java中主要使用的就是Timer对象,他在内部使用的就是多线程的技术. Time类主要负责完成定时计划任务的功能,就是在指定的时间的开始执行某个任务. Timer类的作用是设置计划任务,而封装任务内容的类是TimerTask类.此类是一个抽象类,继承需要实现一个run方法. 通过查文档我们看到Timer有以下几个构造函数: Timer的方法以下这么多: 下面我们通过定时器来完成一个简单功能,就是在运行项目三秒后,在控制台

  • Java定时器Timer简述

    概述 主要用于Java线程里指定时间或周期运行任务.Timer是线程安全的,但不提供实时性(real-time)保证. 构造函数 Timer() 默认构造函数. Timer(boolean) 指定关联线程是否作为daemon线程. Timer(String) 指定关联线程的名称. Timer(String, boolean) 同时指定关联线程的名称和是否作为daemon. schdule方法 schedule(TimerTask task, long delay) 以当前时间为基准,延迟指定的毫

  • Java中的定时器Timer详解

    目录 总结 简单来说,定时器就相当于一个"闹钟",给定时器设定一个任务,约定这个任务在xxx时间之后执行~ Timer类提供了一个核心接口,schedule(安排) 指定一个任务交给定时器,在一定时间之后再去执行这个任务~ 如何实现定时器的效果~ Timer中要包含一个Task类,每个Task就表示一个具体的任务实例,Task里面包含一个时间戳(啥时候执行这个任务),还包含一个Runnable实例(用来表示任务具体是啥). Timer里面通过一个带优先级的阻塞队列,来组织如干个task

  • java使用TimerTask定时器获取指定网络数据

    复制代码 代码如下: import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.net.URL;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Timer;import java.util.TimerTask; public class GetYinInf

  • java定时器timer的使用方法代码示例

    1.首先肯定是容器一启动就要启动定时器,所以我们可以选择把定时器写在一个监听器里,容器一启动所以监听器也就跟着启动,然后定时器就可以工作了. 第一步,把自己写的监听器加到web.xml中: 第二步,写一个监听器,实现ServletContextListener接口: 第三步,写一个定时器,继承TimerTask,在复写的run()方法里写具体的业务逻辑. 第四步,在自己的监听器里复写的 public void contextInitialized(ServletContextEvent arg0

  • java中Timer定时器的使用和启动方式

    目录 Timer定时器的使用和启动 1.概述 2.应用场景 3.使用方法 4.启动方法 java的几种定时器小结 1.@Scheduled注解 2.quartz 3.使用Timer 4.使用线程控制 Timer定时器的使用和启动 1.概述 定时计划任务功能在Java中主要使用的就是Timer对象,它在内部使用多线程的方式进行处理,所以它和多线程技术还是有非常大的关联的.在JDK中Timer类主要负责计划任务的功能,也就是在指定的时间开始执行某一个任务,但封装任务的类却是TimerTask类. 2

  • JAVA中 Spring定时器的两种实现方式

    目前有两种流行Spring定时器配置:Java的Timer类和OpenSymphony的Quartz. 1.Java Timer定时 首先继承java.util.TimerTask类实现run方法 import java.util.TimerTask; public class EmailReportTask extends TimerTask{ @Override public void run() { ... } } 在Spring定义 ... 配置Spring定时器 <bean id=&quo

  • C#中timer定时器用法实例

    本文实例讲述了C#中timer定时器用法.分享给大家供大家参考.具体如下: 下面的代码通过Timer定时器每隔1000毫秒(1秒)触发一次事件 using System; using System.Timers; class TestTimer { public static void Main () { Timer timer = new Timer(); timer.Elapsed + = new ElapsedEventHandler(DisplayTimeEvent); timer.In

  • C#中Timer定时器类的简单使用

    目录 System.Timers.Timer 定时器简单使用 设置初始属性 简单示例–借用官方示例 System.Timers.Timer 定时器就是经过固定时间,执行固定任务. 定时器简单使用 设置初始属性 初始化定时器间隔多少时间执行 System.Timers.Timer timer = new System.Timers.Timer(double interval); interval是毫秒数.比如最后的毫秒数设为1000就是一秒. 也可以用无参构造函数创建后,用对象.interval设

  • 详解Java中数组判断元素存在几种方式比较

    1. 通过将数组转换成List,然后使用List中的contains进行判断其是否存在 public static boolean useList(String[] arr,String containValue){ return Arrays.asList(arr).contains(containValue); } 需要注意的是Arrays.asList这个方法中转换的List并不是java.util.ArrayList而是java.util.Arrays.ArrayList,其中java.

  • Java中枚举类型的一种使用方式

    今天改同事的代码发现同事的代码中有大量的if else语句.很不美观而且可读性太差. 因为需要给前端一个key,value的列表.这个列表写死.然而同事的代码. 放几张图,大家自己感受.我都不知道以后这个api咋维护,新增一个工站,减少一个工站. 果然新的任务新增4个工站,好吧,开始给代码装扮一下. 首先,写一个枚举类. package com.smartflow.common.enumpackage; /** * @author :tao * @date :Created in 2020/8/

  • Java中遍历Map集合的5种方式总结

    方式一 通过Map.keySet使用iterator遍历 @Test public void testHashMap1() { Map<Integer, String> map = new HashMap<>(); map.put(001, "Java"); map.put(002, "数据库"); map.put(003, "Vue"); System.out.println(map); // 通过Map.keySet使

  • 详解Java中的八种单例创建方式

    目录 定义 使用场景 单例模式八种方式 饿汉式(静态常量) 饿汉式(静态代码块) 懒汉式(线程不安全) 懒汉式(同步方法) 懒汉式(同步代码块) 双重检查锁方式 静态内部类方式 枚举方式 总结 定义 单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法) 使用场景 对于一些需要频繁创建销毁的对象 重量级的对象 经常使用到的对象 工具类对象 数据源 session 单例模式八种方式 饿汉式(静态常量) 代码 /**

  • Java中Thread和Runnable创建线程的方式对比

    目录 一.通过继承Thread创建线程 二.实现Runnable创建检查 三.比较两种创建方式 3.1.多继承 3.2. 数据共享 3.3.线程池 四.源码分析 一.通过继承Thread创建线程 通过继承Thread类,创建一个线程,在主线程中,调用start,让线程处于runnable状态,让系统去运行线程的方法. public class MyThread extends Thread { @Override public void run() { System.out.println("执

  • Java中初始化List集合的八种方式汇总

    目录 1.常规方式 2.Arrays 工具类 3.Collections 工具类 4.Lists 工具类 5.匿名内部类 6.ImmutableList 7.Java8 Stream 8.Java9 List.of 总结 List 是在开发中比较常用的集合,今天总结一下 Java 中初始化 List 的几种方式. 1.常规方式 List<String> list = new ArrayList<>(); list.add("1"); list.add("

随机推荐