Javad多线程之定时器Timer

最新推荐文章于 2023-04-03 17:07:46 发布
最新推荐文章于 2023-04-03 17:07:46 发布
阅读量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
    评论
专栏目录
Java 线程定时器
NARA
08-29 528
Java 线程定时器 定时器是一个应用比较广泛的线程工具，可以用来调度多个定时任务，以后台的方式执行。可以通过Timer和TimerTask来实现功能。 Timer是一个普通的类，其中有几个重要的方法；而TimerTask则是一个抽象类，其中有一个抽象方法run()，类似于线程中的run()方法 使用Timer创建一个它的对象，然后使用这个对象的schedule方法来完成这种间隔的操作 Time...
Java多线程之深入学习定时器(Timer)
Q54665642ljf的博客
07-25 1428
Java多线程之深入学习定时器(Timer)包含Timer类和Timermask类
Java多线程核心技术5 - Timer 定时任务、schedule 与 scheduleAtFixedRate
weixin_42593937的博客
01-24 1057
Java多线程核心技术5 - Timer 定时任务、schedule 与 scheduleAtFixedRate5. Timer 定时器5.1 定时器Timer计划时间早于当前时间多个TimerTask任务与延时5.2 schedule vs. scheduleAtFixedRate比较 schedule 与 scheduleAtFixedRate 来自阅读Java多线程编程核心技术的读书笔记，按照自己思路写了一些整理 越读越感觉这本书是一本“口水书”，有堆砌代码案例的嫌疑，看上去感觉更像是一本“博文集”
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 1199
Timer是jdk中提供的一个定时器工具，使用的时候会在主线程之外起一个单独的线程执行指定的计划任务，可以指定执行一次或者反复执行多次。定义了主要有以下6个方法： 顾名思义，schedule与scheduleAtFixedRate 的区别就是——是否按固定速率执行安排指定的任务。 一般情况下，timer的schedule和scheduleAtFixedRate方法没有区别，只在某个情况出...
定时器Timer（三）—— 定时器Timer的使用
qq_44307209的博客
09-09 461
使用 scheduleAtFixedRate 方法：如果执行任务的时间没有被延时，那么下一次任务的执行时间参考的是上一次任务的“结束”时的时间来计算。这就是 Task 任务不追赶的情况。控制台打印的结果证明，在不延时的情况下，如果执行任务的时间没有被延时，则下一次执行任务的时间是上一次任务的开始时间加上 delay 时间。如果执行任务的时间被延时(执行任务的时间大于 delay 的时间)，那么下一次任务的执行时间以上一次任务“结束”时的时间为参考来计算。
Timer 中 scheduleAtFixedRate 方法使用
nandao158的博客
07-16 9297
首先  Timer 通常用来做延时或者循环定时执行的任务。比如：每天闹钟定时， private Timer timer = new Timer(true); @PostConstruct public void setToken(){ if(null == timer){ timer = new Timer(true); } ...
android定时器Timer实例
04-10
请注意，`Timer`线程是非守护线程，如果所有非守护线程都结束，应用程序也将终止。因此，确保在不再需要定时器时调用`timer.cancel()`来取消所有计划的任务，并避免内存泄漏。 尽管`Timer`类在某些场景下方便使用，...
Timer_定时器
07-18
对于更复杂的应用，如在多线程环境下，可能需要使用像`threading.Timer`这样的高级定时器，它可以确保在特定线程中执行任务，并且支持一次性或重复的任务调度。 总结一下，定时器是编程中不可或缺的一部分，它们...
Java小游戏之EpicStubbleMan
最新发布
03-20
开发者可能使用定时器来实现游戏的帧率控制，保证游戏的流畅性，而多线程则可以用于实现并发操作，比如背景音乐播放和游戏逻辑更新可以在不同的线程中进行，避免阻塞主线程。 此外，Java的异常处理机制也是保证程序...
java中timer的schedule和scheduleAtFixedRate方法区别详解
08-28
主要为大家详细介绍了java中timer的schedule和scheduleAtFixedRate方法区别，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
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。...
JavaEE——多线程定时器（Timer）
xyk：的博客
04-03 599
定时器是什么？定时器能做什么？本篇文章带你深入了解并实现定时器是什么？定时器也是软件开发中的一个重要组件. 类似于一个 "闹钟". 达到一个设定的时间之后, 就执行某个指定好的代码定时器是一种实际开发中非常常用的组件，比如网络通信中, 如果对方 500ms 内没有返回数据, 则断开连接尝试重连，比如一个 Map, 希望里面的某个 key 在 3s 之后过期，类似于这样的场景就需要用到定时器。
Timer中schedule和scheduleAtFixedRate方法区别
lolichan的博客
04-23 570
转自：https://blog.csdn.net/ling912439122/article/details/52712406   Timer，一般用来做延时任务或者循环定时执行的任务。 例如：指定在一小时后闹钟就响了，或者每天6:00响，这些都是延时任务或者是定时循环的任务   使用Timer的时候，必须要有一个TimerTask去执行任务，这是一个线程，它实现了Runnable接...
Timer的schedule方法和scheduleAtFixedRate方法的区别
Deronn的博客
05-10 454
Timer，一般用来做延时、定时任务（一次性）或者循环定时执行的任务。例如：指定在一小时后闹钟就响了，或者每天6:00响，这些都是延时任务或者是定时循环的任务。在使用Timer的时候，要新建TimerTask去执行任务，这是一个线程，它实现了Runnable接口，run方法里面就是线程需要做的，也是我们自己定义的。可以创建多个TimerTask然后添加到Timer里面，但是因为Timer里面本质是...
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 * 创建并执行一个在给定的初始延迟之后才
ScheduledThreadPoolExecutor的scheduleAtFixedRate方法探究（周期时间是否受command的执行时间影响）...
weixin_30905133的博客
03-10 152
http://www.cnblogs.com/sunxucool/archive/2013/06/21/3148141.html 转载于:https://www.cnblogs.com/soaringEveryday/articles/4325889.html
java简单的生产者消费者问题代码实例
大鹏视界U
03-29 3236
学习java多线程的synchronized关键字与wait/notify等待唤醒机制。 又想到了操作系统里的消费者与生产者模式，写了个小例子加深理解。 共享资源为Food类 代码如下： public class Food { private int count;//生产者与消费者共享的资源 public Food() { } public synchronized int getCo...
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、付费专栏及课程。

余额充值