Javad多线程之定时器Timer

最新推荐文章于 2022-09-09 19:08:13 发布
最新推荐文章于 2022-09-09 19:08:13 发布
阅读量230 收藏
点赞数
分类专栏： Java并发编程 文章标签： java并发编程 定时器 Timer TimerTask
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14842117/article/details/89554408
版权

定时器Timer的使用

在JDK库中，Timer类主要负责计划任务的功能，也就是在指定的时间开始执行某一个任务
Timer类的主要作用就是设置计划任务，但封装任务的类却是TimerTask类
执行计划任务的代码要放入TimerTask的子类中，因为TimerTask是一个抽象类。

5.1.1 方法schedule(TimerTask task,Date time)

该方法的作用是在指定的日期执行一次某一个任务

第一种情况：执行任务的时间晚于当前时间

package cn.yu.thread;

import java.util.Date;
import java.util.TimerTask;

public class MyTask extends TimerTask {

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"任务执行，完成时间为："+new Date());
	}
  
}
.....................
package cn.yu.thread;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Calendar;
import java.util.Date;
import java.util.Timer;

public class Test {
public static void main(String[] args) throws InterruptedException {
	System.out.println("当前时间为："+new Date());
	
	Calendar calendarRef2 = Calendar.getInstance();
	calendarRef2.add(Calendar.SECOND, 10);比当前时间晚10秒
	Date runDate2 = calendarRef2.getTime();
	System.out.println("计划时间为："+runDate2);
	MyTask task = new MyTask();
	Timer timer = new Timer();
	timer.schedule(task,runDate2);
	
  }
}
运行时间：
当前时间为：Fri Apr 26 15:13:30 CST 2019
计划时间为：Fri Apr 26 15:13:40 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:13:40 CST 2019

创建一个Timer就是启动一个新的线程，那么这个启动的线程并不是守护线程，一直在运行，
如果将Timer改为守护线程。

public class Test {
public static void main(String[] args) throws InterruptedException {
	System.out.println("当前时间为："+new Date());
	
	Calendar calendarRef2 = Calendar.getInstance();
	calendarRef2.add(Calendar.SECOND, 10);
	Date runDate2 = calendarRef2.getTime();
	System.out.println("计划时间为："+runDate2);
	MyTask task = new MyTask();
	Timer timer = new Timer(true);//守护线程
	timer.schedule(task,runDate2);
	
  }
}
运行结果：
当前时间为：Fri Apr 26 15:17:39 CST 2019
计划时间为：Fri Apr 26 15:17:49 CST 2019

可以看见TimerTask中的任务不被运行，因为进程已经结束。

第二种情况： 计划时间早于当前时间

public class Test {
public static void main(String[] args) throws InterruptedException {
	System.out.println("当前时间为："+new Date());
	
	Calendar calendarRef2 = Calendar.getInstance();
	calendarRef2.add(Calendar.SECOND, -10); 比当前时间早10秒
	Date runDate2 = calendarRef2.getTime();
	System.out.println("计划时间为："+runDate2);
	MyTask task = new MyTask();
	Timer timer = new Timer();
	timer.schedule(task,runDate2);
	
  }
}

运行结果：
当前时间为：Fri Apr 26 15:14:29 CST 2019
计划时间为：Fri Apr 26 15:14:19 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:14:29 CST 2019

如果执行任务的时间早于当前时间，则立即执行task任务。

第三种情况：Timer中允许有多个TimerTask任务及延时

package cn.yu.thread;

import java.util.Date;
import java.util.TimerTask;

public class MyTaskA  extends TimerTask{

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"开始："+new Date());
		try {
			Thread.sleep(10000);
			System.out.println(Thread.currentThread().getName()+"结束"+new Date());
		} catch (InterruptedException e) {
			
			e.printStackTrace();
		}
	}
  
}
.........................
package cn.yu.thread;

import java.util.Date;
import java.util.TimerTask;

public class MyTaskB extends TimerTask{

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"开始："+new Date());
		System.out.println(Thread.currentThread().getName()+"结束"+new Date());
	}
}
................................
public class Test {
public static void main(String[] args) throws InterruptedException {
	System.out.println("当前时间为："+new Date());
	Calendar calendarRef1 = Calendar.getInstance();
	Date runDate1 = calendarRef1.getTime();
	System.out.println("A计划时间为："+runDate1);
	Calendar calendarRef2 = Calendar.getInstance();
	calendarRef2.add(Calendar.SECOND, 5);
	Date runDate2 = calendarRef2.getTime();
	System.out.println("B计划时间为："+runDate2);
	MyTaskA task1 = new MyTaskA();
	MyTaskB task2 = new MyTaskB();
	Timer timer = new Timer();
	timer.schedule(task1,runDate1);
	timer.schedule(task2, runDate2);
  }
}
运行结果：
当前时间为：Fri Apr 26 15:23:59 CST 2019
A计划时间为：Fri Apr 26 15:23:59 CST 2019
B计划时间为：Fri Apr 26 15:24:04 CST 2019
Timer-0开始：Fri Apr 26 15:23:59 CST 2019
Timer-0结束Fri Apr 26 15:24:09 CST 2019
Timer-0开始：Fri Apr 26 15:24:09 CST 2019
Timer-0结束Fri Apr 26 15:24:09 CST 2019

从运行结果上看，有两点发现：
1.Thread.currentThread().getName() 两个TimerTask得到的都是Timer-0,说明一个Timer对象创建一个线程对象，TimerTask只是封装了一个任务。
2.在代码中设置任务1和任务2的运行间隔时间为5秒，由于task1需要用时10秒完成，所以task1需要用时10秒执行完任务，所以task1结束时间就是task2的开始时间，不在以10秒作为参考，究其原理还是因为Task是放入队列的，得一个一个运行。

5.1.2 方法schedule(TimerTask task,Date firstTime,long period)

该方法的作用是在指定的日期之后按指定的间隔周期，无限循环地执行某一任务

第一种情况：计划时间晚于当前时间

public class MyTask extends TimerTask {

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"任务执行，完成时间为："+new Date());
	}
  
}
........................
public class Test {
public static void main(String[] args) throws InterruptedException {
	System.out.println("当前时间为："+new Date());
	
	Calendar calendarRef2 = Calendar.getInstance();
	calendarRef2.add(Calendar.SECOND, 5);
	Date runDate2 = calendarRef2.getTime();
	System.out.println("B计划时间为："+runDate2);
	MyTask task = new MyTask() ;
	Timer timer = new Timer();

	timer.schedule(task, runDate2,4000);
  }
}
运行结果：
当前时间为：Fri Apr 26 15:31:30 CST 2019
B计划时间为：Fri Apr 26 15:31:35 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:31:35 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:31:39 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:31:43 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:31:47 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:31:51 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:31:55 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:31:59 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:32:03 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:32:07 CST 2019

第二种情况： 计划时间早于当前时间

如果计划时间早于当前时间，则立即执行task任务

第三种情况：任务执行时间被延时

public class MyTask extends TimerTask {

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"任务执行，开始时间为："+new Date());
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName()+"任务执行，完成时间为："+new Date());
	}
  
}
.................................
public class Test {
public static void main(String[] args) throws InterruptedException {
	System.out.println("当前时间为："+new Date());
	
	Calendar calendarRef2 = Calendar.getInstance();
	calendarRef2.add(Calendar.SECOND, 10);
	Date runDate2 = calendarRef2.getTime();
	System.out.println("任务计划时间为："+runDate2);
	MyTask task = new MyTask() ;
	Timer timer = new Timer();

	timer.schedule(task, runDate2,3000);
  }
}
运行结果：
当前时间为：Fri Apr 26 15:40:38 CST 2019
任务计划时间为：Fri Apr 26 15:40:48 CST 2019
Timer-0任务执行，开始时间为：Fri Apr 26 15:40:48 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:40:53 CST 2019
Timer-0任务执行，开始时间为：Fri Apr 26 15:40:53 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:40:58 CST 2019
Timer-0任务执行，开始时间为：Fri Apr 26 15:40:58 CST 2019
Timer-0任务执行，完成时间为：Fri Apr 26 15:41:03 CST 2019
Timer-0任务执行，开始时间为：Fri Apr 26 15:41:03 CST 2019

从上面看任务被延时了，但还得一个一个运行

5.1.3 TimerTask类的cancel()方法

TimerTask类中的cancel()方法的作用是将自身从任务队列中进行清除

public class MyTaskA  extends TimerTask{

	@Override
	public void run() {
		System.out.println("A run timer"+new Date());
		this.cancel();
		System.out.println("A任务自己移出自己");	
	}
}
.............................................
public class MyTaskB extends TimerTask{

	@Override
	public void run() {
		System.out.println("B run timer="+new Date());
		
	}
}
......................................
public class Test {
public static void main(String[] args) throws InterruptedException {
	System.out.println("当前时间为："+new Date());
	
	Calendar calendarRef2 = Calendar.getInstance();
	//calendarRef2.add(Calendar.SECOND, 10);
	Date runDate2 = calendarRef2.getTime();
	System.out.println("任务计划时间为："+runDate2);
	MyTaskA task1 = new MyTaskA() ;
	MyTaskB task2 = new MyTaskB() ;
	Timer timer = new Timer();

	timer.schedule(task1, runDate2,3000);
	timer.schedule(task2, runDate2,3000);
  }
}
运行结果：
当前时间为：Fri Apr 26 15:49:24 CST 2019
任务计划时间为：Fri Apr 26 15:49:24 CST 2019
A run timerFri Apr 26 15:49:24 CST 2019
A任务自己移出自己
B run timer=Fri Apr 26 15:49:24 CST 2019
B run timer=Fri Apr 26 15:49:27 CST 2019
B run timer=Fri Apr 26 15:49:30 CST 2019
B run timer=Fri Apr 26 15:49:33 CST 2019
B run timer=Fri Apr 26 15:49:36 CST 2019
B run timer=Fri Apr 26 15:49:39 CST 2019

5.1.4 Timer类的cancel()方法

和TimerTask类中的cancel()方法清除自身不同，Timer类中的cancel()方法作用是将任务队列中全部的任务进行清空。

package cn.yu.thread;

import java.util.Date;
import java.util.TimerTask;

public class MyTaskA  extends TimerTask{

	@Override
	public void run() {
		System.out.println("A run timer"+new Date());
		
	}
}
...............................
package cn.yu.thread;

import java.util.Date;
import java.util.TimerTask;

public class MyTaskB extends TimerTask{

	@Override
	public void run() {
		System.out.println("B run timer="+new Date());
		
	}
}
.............................................
public class Test {
public static void main(String[] args) throws InterruptedException {
	System.out.println("当前时间为："+new Date());
	
	Calendar calendarRef2 = Calendar.getInstance();
	//calendarRef2.add(Calendar.SECOND, 10);
	Date runDate2 = calendarRef2.getTime();
	System.out.println("任务计划时间为："+runDate2);
	MyTaskA task1 = new MyTaskA() ;
	MyTaskB task2 = new MyTaskB() ;
	Timer timer = new Timer();

	timer.schedule(task1, runDate2,2000);
	timer.schedule(task2, runDate2,2000);
	Thread.sleep(5000);
	timer.cancel();
	System.out.println("任务全部取消");
  }
}
运行结果：
当前时间为：Fri Apr 26 15:59:52 CST 2019
任务计划时间为：Fri Apr 26 15:59:52 CST 2019
A run timerFri Apr 26 15:59:52 CST 2019
B run timer=Fri Apr 26 15:59:52 CST 2019
A run timerFri Apr 26 15:59:54 CST 2019
B run timer=Fri Apr 26 15:59:54 CST 2019
A run timerFri Apr 26 15:59:56 CST 2019
B run timer=Fri Apr 26 15:59:56 CST 2019
任务全部取消

注意事项：Timer类的cancel()方法有时并不一定会停止计划任务，而是正常执行。

import java.util.Date;
import java.util.TimerTask;

public class MyTaskA  extends TimerTask{
   private int i;
   public MyTaskA(int i) {
	   super();
	   this.i = i;
   }
	@Override
	public void run() {
		System.out.println("第"+i+"次没有被cancel取消");
		
	}
}
...........................
public class Test {
public static void main(String[] args) throws InterruptedException {
	int i = 0;
	Calendar calendarRef1 = Calendar.getInstance();
	Date runDate1 = calendarRef1.getTime();
	while(true) {
		i++;
		Timer timer = new Timer();
		MyTaskA task1 = new MyTaskA(i);
		timer.schedule(task1,runDate1);
		timer.cancel();
	}
  }
}
......................
运行结果：
第46463次没有被cancel取消
第223973次没有被cancel取消
第259984次没有被cancel取消

看一下Timer 的cancel()方法的源码：

  private final TaskQueue queue = new TaskQueue();
public void cancel() {
        synchronized(queue) {
            thread.newTasksMayBeScheduled = false;
            queue.clear();
            queue.notify();  // In case queue was already empty.
        }
    }
 原因是：cancel()方法不一定能抢到queue锁

5.1.4 方法schedule(TimerTask task,long delay)

该方法的作用是以执行schedule(TimerTask task,long delay)方法当前的时间为参考时间，在此基础上延迟指定的毫秒数后执行一次TimerTask任务。

5.1.5 方法schedule(TimerTask task,long delay,long period)

该方法的作用是以执行schedule(TimerTask task,long delay,long period)方法当前时间为参考时间，在此时间基础上延迟指定的毫秒数，再以某一间隔时间无限次数地执行某一任务。

5.1.6 方法scheduleAtFixedRate(TimerTask task,Date firstTime,long period)

方法schedule()和方法scheduleAtFixedRate()都会按顺序执行，所以不要考虑非线程安全的情况。

方法schedule和scheduleAtFixedRate主要的区别只在与有没有追赶特性。

验证scheduleAtFixedRate方法具有追赶执行性

public class MyTask extends TimerTask {

	@Override
	public void run() {
		System.out.println("begin timer"+new Date());
		System.out.println("end timer="+new Date());
	}
  
}
................................
public class Test {
	 static class MyTask extends TimerTask{

		@Override
		public void run() {
			System.out.println("begin timer"+new Date());
			System.out.println("end timer="+new Date());
		}
		 
	 }
public static void main(String[] args) throws InterruptedException {
	MyTask task = new MyTask();
	System.out.println("现在执行时间"+new Date());
	Calendar calendar = Calendar.getInstance();
	calendar.set(calendar.SECOND,calendar.get(Calendar.SECOND)-20);
	Date runDate = calendar.getTime();
	System.out.println("计划执行时间"+runDate);
	Timer timer = new Timer();
	timer.scheduleAtFixedRate(task, runDate,2000);
  }
}

运行结果：
现在执行时间Fri Apr 26 16:35:00 CST 2019
计划执行时间Fri Apr 26 16:34:40 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:00 CST 2019
end timer=Fri Apr 26 16:35:00 CST 2019
begin timerFri Apr 26 16:35:02 CST 2019
end timer=Fri Apr 26 16:35:02 CST 2019
begin timerFri Apr 26 16:35:04 CST 2019
end timer=Fri Apr 26 16:35:04 CST 2019
begin timerFri Apr 26 16:35:06 CST 2019
end timer=Fri Apr 26 16:35:06 CST 2019
begin timerFri Apr 26 16:35:08 CST 2019
end timer=Fri Apr 26 16:35:08 CST 2019
begin timerFri Apr 26 16:35:10 CST 2019
end timer=Fri Apr 26 16:35:10 CST 2019
begin timerFri Apr 26 16:35:12 CST 2019
end timer=Fri Apr 26 16:35:12 CST 2019
begin timerFri Apr 26 16:35:14 CST 2019
end timer=Fri Apr 26 16:35:14 CST 2019
begin timerFri Apr 26 16:35:16 CST 2019
end timer=Fri Apr 26 16:35:16 CST 2019

程序中设置任务执行时间为当前时间的前20秒，每2秒重复一次，所有在当前时间之前要执行任务10次，这就是Task任务的追赶性。

如果换成schedule呢？

现在执行时间Fri Apr 26 16:39:26 CST 2019
计划执行时间Fri Apr 26 16:39:06 CST 2019
begin timerFri Apr 26 16:39:26 CST 2019
end timer=Fri Apr 26 16:39:26 CST 2019
begin timerFri Apr 26 16:39:28 CST 2019
end timer=Fri Apr 26 16:39:28 CST 2019
begin timerFri Apr 26 16:39:30 CST 2019
end timer=Fri Apr 26 16:39:30 CST 2019
begin timerFri Apr 26 16:39:32 CST 2019
end timer=Fri Apr 26 16:39:32 CST 2019
begin timerFri Apr 26 16:39:34 CST 2019
end timer=Fri Apr 26 16:39:34 CST 2019
begin timerFri Apr 26 16:39:36 CST 2019
end timer=Fri Apr 26 16:39:36 CST 2019

可以看到任务执行从当前时间以后，不具有追赶性。

迷糊弟弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android定时器Timer实例
04-10
请注意，`Timer`线程是非守护线程，如果所有非守护线程都结束，应用程序也将终止。因此，确保在不再需要定时器时调用`timer.cancel()`来取消所有计划的任务，并避免内存泄漏。 尽管`Timer`类在某些场景下方便使用，...
Timer_定时器
07-18
对于更复杂的应用，如在多线程环境下，可能需要使用像`threading.Timer`这样的高级定时器，它可以确保在特定线程中执行任务，并且支持一次性或重复的任务调度。 总结一下，定时器是编程中不可或缺的一部分，它们...
Java多线程（十四）：Timer
qq_30684181的博客
09-20 156
Timer schedule(TimerTask task, Date time) 该方法在指定日期执行任务，如果是过去的时间，这个任务会立即被执行。 执行时间早于当前时间 示例代码，当前时间是2019年9月19日，代码中写的是前一天的时间。 public class MyTask1 extends TimerTask { private static Timer timer =...
java 多线程 timer_【Java多线程】――定时器Timer的使用
weixin_42522167的博客
02-16 280
abstractclassTimerTaskimplementsRunnable{...}一、schedule多个任务计划执行首先先来看一下Timer的最基本用法，schedule(TimerTask, Date)，我们要先创建一个类继承TimerTask类，并重写run()方法，然后实例化这个类的对象，作为schedule(TimerTask, Date)方法的参数之一。另一个参数是我们需要Ti...
java多线程：2、Timer实现
梦想的翅膀
04-09 229
Timer简单使用实例1S后调度任务执行new Timer().schedule(new TimerTask(){ @Override public void run() { // TODO Auto-generated method stub System.out.println("1S后调度任务执行"); }}, 1000);1S后调度任务
java多线程之Timer源码剖析
W.J.H.
02-28 286
一、类结构图 二、源码 2.1 Timer中的成员变量，可见其中有TaskQueue、TimerThread。TaskQueue用于存储每次schedule的Task，它是一个优先队列，最近执行的Task会排在队头。而TimerThread是一个线程，它负责判断TaskQueue中的task周期是否到达，并调用它。 /** * The timer task queue. This ...
java多线程：volatile及Timer用法示例
软件与编程的零零碎碎
12-29 1433
最近写程序时，需要在java中使用多线程共享程序变量。 特别地，我需要另一个线程中执行类A的方法function_1。但给定的执行时间只有n毫秒，也就是说我会在n毫秒之后终止function_1的执行。 但问题是，我在主线程随后的代码中无法判断funcion_1是寿终正寝呢，还是被我的主线程杀死的。我想到的解决方案就是在类A中设置一个标志变量finished，初始为false。当functio
Java小游戏之EpicStubbleMan
最新发布
03-20
开发者可能使用定时器来实现游戏的帧率控制，保证游戏的流畅性，而多线程则可以用于实现并发操作，比如背景音乐播放和游戏逻辑更新可以在不同的线程中进行，避免阻塞主线程。 此外，Java的异常处理机制也是保证程序...
Java小游戏之Grndzero
03-20
Java虚拟机（JVM）允许开发者通过调整内存分配、使用并发和多线程来提升性能。例如，可以使用并发库（如`java.util.concurrent`包）实现异步任务，以减少主游戏循环的阻塞时间。另外，合理的数据结构和算法选择能...
Linux多线程服务端编程：使用muduo C++网络库
08-17
《Linux多线程服务端编程：使用muduo C++网络库》主要讲述采用现代C++在x86-64 Linux上编写多线程TCP网络服务程序的主流常规技术，重点讲解一种适应性较强的多线程服务器的编程模型，即one loop per thread。...
Java中Timer的用法
D的博客
11-24 450
现在项目中用到需要定时去检查文件是否更新的功能。timer正好用于此处。 用法很简单，new一个timer，然后写一个timertask的子类即可。 代码如下： [java] view plain copy package comz.autoupdatefile;    import java.util.Timer;  import java.util.Timer
Timer的schedule和scheduleAtFixedRate方法的区别解析
热门推荐
星星的技术专栏
11-27 6万+
在java中，Timer类主要用于定时性、周期性任务 的触发，这个类中有两个方法比较难理解，那就是schedule和scheduleAtFixedRate方法，在这里就用实例分析一下 （1）schedule方法：“fixed-delay”；如果第一次执行时间被delay了，随后的执行时间按照实际执行完成的时间点进行计算 （2）scheduleAtFixedRate方法：“fixed-rate”；如果第一次执行时间被delay了，随后的执行时间按照初始设定时间点进行计算，并且为了”catch up”会多
Timer类中的 scheduleAtFixedRate与schedule
sinat_41838539的博客
01-14 1198
Timer是jdk中提供的一个定时器工具，使用的时候会在主线程之外起一个单独的线程执行指定的计划任务，可以指定执行一次或者反复执行多次。定义了主要有以下6个方法： 顾名思义，schedule与scheduleAtFixedRate 的区别就是——是否按固定速率执行安排指定的任务。 一般情况下，timer的schedule和scheduleAtFixedRate方法没有区别，只在某个情况出...
定时器Timer（三）—— 定时器Timer的使用
qq_44307209的博客
09-09 461
使用 scheduleAtFixedRate 方法：如果执行任务的时间没有被延时，那么下一次任务的执行时间参考的是上一次任务的“结束”时的时间来计算。这就是 Task 任务不追赶的情况。控制台打印的结果证明，在不延时的情况下，如果执行任务的时间没有被延时，则下一次执行任务的时间是上一次任务的开始时间加上 delay 时间。如果执行任务的时间被延时(执行任务的时间大于 delay 的时间)，那么下一次任务的执行时间以上一次任务“结束”时的时间为参考来计算。
Timer 中 scheduleAtFixedRate 方法使用
nandao158的博客
07-16 9296
首先  Timer 通常用来做延时或者循环定时执行的任务。比如：每天闹钟定时， private Timer timer = new Timer(true); @PostConstruct public void setToken(){ if(null == timer){ timer = new Timer(true); } ...
Java—Timer的简单使用—schedule和scheduleAtFixedRate的区别
不求重复造轮子，但必须要知道轮子是怎么造的。
09-30 2万+
Timer，一般用来做延时任务或者循环定时执行的任务。 例如：指定在一小时后闹钟就响了，或者每天6:00响，这些都是延时任务或者是定时循环的任务 使用Timer的时候，必须要有一个TimerTask去执行任务，这是一个线程，它实现了Runnable接口，run方法里面就是线程需要做的，也是我们自己定义的。 下面来看代码： 上面几行代码只是定义了一个Date和一个Ti
ScheduledExecutorService定时周期执行指定的任务 ，关于scheduleAtFixedRate 和 scheduleWithFixedDelay使用区别
阿亮
08-29 2950
在项目中使用到了多线程定时执行指定任务中发现以下一些问题：/** * Creates and executes a periodic action that becomes enabled first * after the given initial delay, and subsequently with the given * 创建并执行一个在给定的初始延迟之后才
Timer中schedule和scheduleAtFixedRate方法区别
lolichan的博客
04-23 570
转自：https://blog.csdn.net/ling912439122/article/details/52712406   Timer，一般用来做延时任务或者循环定时执行的任务。 例如：指定在一小时后闹钟就响了，或者每天6:00响，这些都是延时任务或者是定时循环的任务   使用Timer的时候，必须要有一个TimerTask去执行任务，这是一个线程，它实现了Runnable接...
Java定时器（实现每月1号、每日、每15分钟自动执行任务）
五道口
03-20 4万+
需求： 在tomcat中，每月一号、每日、每分钟自动执行指定的任务。 开发环境： java1.7+ tomcat 实现思路： 在tomcat中，添加监听器，在监听器中设置定时任务。 1.监听： 新建监听类implents ServletContextListener，实现其中的方法即可。 讲解： 1.1：创建一个基准时间defaultdate（每日8点），用于参照，在此时间以...
Swing定时器：Java多线程与事件调度
该资源主要介绍了Swing中的定时器及其在Java多线程环境下的应用。Swing定时器是Java GUI编程中一个重要的工具，它允许开发者设置延迟时间后执行特定的任务。 Swing定时器（javax.swing.Timer）是专门为Swing组件...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值