java并发编程之计划任务ScheduledExecutorService的使用

最新推荐文章于 2024-07-21 14:45:49 发布
最新推荐文章于 2024-07-21 14:45:49 发布
阅读量2.6k 收藏 2
点赞数
分类专栏： Java并发编程 文章标签： java并发编程 ScheduledExecutorService
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14842117/article/details/89599841
版权

java中的计划任务Timer工具类提供了以计时器或计划任务的功能来实现按指定时间或时间间隔
执行任务，但由于Timer工具类并不是以池pool,而是以队列的方法来管理线程的，所以在高并发的情况下运行效率较低，在新版JDK中提供了ScheduledExecutorService对象来解决效率与定时任务的功能。

8.1 ScheduledExecutorService的使用

类ScheduledExecutorService的主要作用就是可以将定时任务与线程池功能结合使用。
ScheduledThreadPoolExecutor的父接口还是Executor
类ScheduledThreadPoolExecutor的父类是ThreadPoolExecutor

8.2 ScheduledThreadPoolExecutor使用Callable延迟运行

本示例使用Callable接口进行任务延迟运行的实验，具有返回值的功能

public class MyCallableA implements Callable<String> {

	@Override
	public String call() throws Exception {
		 System.out.println("callA begin"+Thread.currentThread().getName()+" "+System.currentTimeMillis());
		 Thread.sleep(3000);
		 System.out.println("callA end"+Thread.currentThread().getName()+" "+System.currentTimeMillis());
		return "A线程";
	}

}
................................
public class MyCallableB implements Callable<String>{

	@Override
	public String call() throws Exception {
		 System.out.println("callB begin"+Thread.currentThread().getName()+" "+System.currentTimeMillis());
		 
		 System.out.println("callB end"+Thread.currentThread().getName()+" "+System.currentTimeMillis());
		return "B线程";
	}

}
.............................
public class Test {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
	List<Callable> callableList = new ArrayList();
	callableList.add(new MyCallableA());
	callableList.add(new MyCallableB());
	//调用方法newSingleThreadScheduledExecutor()
	//取得一个单任务的计划任务池
	ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
	ScheduledFuture<String> futureA = executor.schedule(callableList.get(0), 4L,TimeUnit.SECONDS);//任务4秒后执行
	ScheduledFuture<String> futureB = executor.schedule(callableList.get(1),4L,TimeUnit.SECONDS );//任务4秒后执行
	System.out.println("开始"+System.currentTimeMillis());
	System.out.println("返回值A:"+futureA.get());
	System.out.println("返回值B:"+futureB.get());
	System.out.println("结束"+System.currentTimeMillis());
  }
}
运行结果：
开始1556335280921
callA beginpool-1-thread-1 1556335284921
callA endpool-1-thread-1 1556335287921
返回值A:A线程
callB beginpool-1-thread-1 1556335287921
callB endpool-1-thread-1 1556335287922
返回值B:B线程
结束1556335287922

从开始到结束的运行时间为7秒，阻塞点是get()方法。
从运行结果上看：
public <V>ScheduleFuture<V>schedule(<V>long delay,TimeUnit unit)方法中的第二个参数在多个任务中同时消耗时间，并不是一个任务执行完毕后在等待4秒继续执行的效果。由于第1个任务从计划任务到运行结束需要用时7秒，那么第二个任务其实是想在第4秒后执行，由于是单任务的计划任务池，所以第二个任务的执行时间被延后3秒。

在此实验中使用工厂类Executors的newSingleThreadScheduledExecutor()方法来创建ScheduleExecutorService对象，但返回的真正对象确实ScheduledThreadPoolExecutor,因为ScheduledThreadPoolExecutor实现了ScheduledExecutorService接口。

方法newSingleThreadScheduleExecutor()在JDK中的源代码如下：

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }

从源代码中还可以发现，调用newSingleThreadScheduledExecutor()方法时，在源代码中实例化new ScheduledThreadPoolExecutor(1)对象时传入参数为1，是单任务执行的计划任务池。

public class Test {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
	List<Callable> callableList = new ArrayList();
	callableList.add(new MyCallableA());
	callableList.add(new MyCallableB());
	//调用方法newScheduledThreadPool(corePoolSize)
	//取得一个同时运行corePoolSize任务个数的计划任务执行池ScheduledExecutorService
	ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
	ScheduledFuture<String> futureA = executor.schedule(callableList.get(0), 4L,TimeUnit.SECONDS);
	ScheduledFuture<String> futureB = executor.schedule(callableList.get(1),4L,TimeUnit.SECONDS );
	System.out.println("开始"+System.currentTimeMillis());
	System.out.println("返回值A:"+futureA.get());
	System.out.println("返回值B:"+futureB.get());
	System.out.println("结束"+System.currentTimeMillis());
  }
}

运行结果：
开始1556336913929
callA beginpool-1-thread-1 1556336917931
callB beginpool-1-thread-2 1556336917931
callB endpool-1-thread-2 1556336917931
callA endpool-1-thread-1 1556336920931
返回值A:A线程
返回值B:B线程
结束1556336920931

从结果看出，任务A,B都是4秒后执行，A花了3秒执行完毕。

newScheduledThreadPool源码：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

8.3 ScheduledThreadPoolExecutor使用Runnable延迟运行

除了没返回值，其他效果同Callable一样

8.4 使用scheduleAtFixedRate()方法实现周期性执行

此示例测试的是执行任务的时间大于>period预定的周期时间，也就是产生了超时效果。


方法scheduleAtFixedRate()
  public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);
public class Test {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
	List<Callable> callableList = new ArrayList();
//	callableList.add(new MyCallableA());
//	callableList.add(new MyCallableB());
//	//调用方法newScheduledThreadPool(corePoolSize)
//	//取得一个同时运行corePoolSize任务个数的计划任务执行池ScheduledExecutorService
//	ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
//	ScheduledFuture<String> futureA = executor.schedule(callableList.get(0), 4L,TimeUnit.SECONDS);
//	ScheduledFuture<String> futureB = executor.schedule(callableList.get(1),4L,TimeUnit.SECONDS );
//	System.out.println("开始"+System.currentTimeMillis());
//	System.out.println("返回值A:"+futureA.get());
//	System.out.println("返回值B:"+futureB.get());
//	System.out.println("结束"+System.currentTimeMillis());
	
	ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
	System.out.println("X="+System.currentTimeMillis());
	executor.scheduleAtFixedRate(new MyRunnable(), 4, 2, TimeUnit.SECONDS);//四秒后开始执行，每两秒开始执行
	System.out.println("Y="+System.currentTimeMillis());
  }
}
运行结果：
X=1556338461067
Y=1556338461069
begin=1556338465071ThreadName=pool-1-thread-1
end = 1556338469071ThreadName=pool-1-thread-1
begin=1556338469071ThreadName=pool-1-thread-1
end = 1556338473072ThreadName=pool-1-thread-1
begin=1556338473072ThreadName=pool-1-thread-1
end = 1556338477072ThreadName=pool-1-thread-1
begin=1556338477072ThreadName=pool-1-thread-1
end = 1556338481072ThreadName=pool-1-thread-1
begin=1556338481072ThreadName=pool-1-thread-1
end = 1556338485072ThreadName=pool-1-thread-1
begin=1556338485072ThreadName=pool-1-thread-1
。。。。。。。。。。。。。。。。。

上面运行结果，虽然让每两秒执行一次，但任务时间是4秒，所以，所有任务都延迟了。

scheduleAtFixedRate()方法返回的ScheduledFuture对象无法获得返回值，也就是scheduleAtFixedRate(）方法不具有获得返回值的功能，而schedule(）方法却可以获得返回值。所以当使用scheduleAtFixedRate(）方法实现重复运行任务的效果时，需要结合自定义Runnable接口的实现类，不要使用FutureTask类，因为FutureTask类并不能实现重复运行的效果。

8.5 使用scheduleWithFixedDelay()方法实现周期性执行

方法scheduleWithFixedDelay()的主要作用是设置多个任务之间固定的运行时间间隔。
第一个实验 执行任务时间大于 period预定的时间

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);
方法scheduleWithFixedDelay()并没有超时与非超时的情况，
参数 long  delay的主要作用就是下一个任务的开始时间与上一个任务的结束时间的时间间隔

8.6 使用getQueue()与remove()方法
方法getQueue()的作用是取得队列中的任务，而这些任务是未来将要运行的，正在运行的任务不在此队列中，使用scheduleAtFixedRate(）和scheduleWithFixedDelay()两个方法实现周期性执行任务时，未来欲执行的任务都是放入此队列中。

public class MyRunnable implements Runnable{
  
	private String username;
	public MyRunnable(String username) {
		super();
		this.username = username;
	}
	
	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	@Override
	public void run() {
	System.out.println("run!username="+" "+Thread.currentThread().getName()+":"+System.currentTimeMillis());
	}

}
..............................
public class Test {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
	 ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10);
	 Runnable runnable1 = new MyRunnable("A");
	 Runnable runnable2 = new MyRunnable("B");
	 Runnable runnable3 = new MyRunnable("C");
	 Runnable runnable4 = new MyRunnable("D");
	 Runnable runnable5 = new MyRunnable("E");
	 System.out.println(runnable1.hashCode());
	 System.out.println(runnable2.hashCode());
	 System.out.println(runnable3.hashCode());
	 System.out.println(runnable4.hashCode());
	 System.out.println(runnable5.hashCode());
	 executor.scheduleAtFixedRate(runnable1, 10, 2, TimeUnit.SECONDS);
	 executor.scheduleAtFixedRate(runnable2, 10, 2, TimeUnit.SECONDS);
	 executor.scheduleAtFixedRate(runnable3, 10, 2, TimeUnit.SECONDS);
	 executor.scheduleAtFixedRate(runnable4, 10, 2, TimeUnit.SECONDS);
	 executor.scheduleAtFixedRate(runnable5, 10, 2, TimeUnit.SECONDS);
	 System.out.println();
	 BlockingQueue<Runnable> queue = executor.getQueue();
	 Iterator<Runnable> iterator = queue.iterator();
	 while(iterator.hasNext()) {
		 Runnable runnable = (Runnable)iterator.next();
		 System.out.println("队列中的"+runnable);
	 }
  }
}
..............................................
运行结果：
455896770
1323165413
1880587981
511754216
1721931908

队列中的java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask@1f17ae12[Not completed, task = java.util.concurrent.Executors$RunnableAdapter@300ffa5d[Wrapped task = cn.yu.scheduledexecutorservice.MyRunnable@1b2c6ec2]]
队列中的java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask@6193b845[Not completed, task = java.util.concurrent.Executors$RunnableAdapter@4d405ef7[Wrapped task = cn.yu.scheduledexecutorservice.MyRunnable@4edde6e5]]
队列中的java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask@c4437c4[Not completed, task = java.util.concurrent.Executors$RunnableAdapter@2e817b38[Wrapped task = cn.yu.scheduledexecutorservice.MyRunnable@70177ecd]]
队列中的java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask@3f91beef[Not completed, task = java.util.concurrent.Executors$RunnableAdapter@433c675d[Wrapped task = cn.yu.scheduledexecutorservice.MyRunnable@1e80bfe8]]
队列中的java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask@37bba400[Not completed, task = java.util.concurrent.Executors$RunnableAdapter@1a6c5a9e[Wrapped task = cn.yu.scheduledexecutorservice.MyRunnable@66a29884]]
run!username= pool-1-thread-1:1556344657608
run!username= pool-1-thread-3:1556344657608
run!username= pool-1-thread-2:1556344657608
run!username= pool-1-thread-3:1556344657609
run!username= pool-1-thread-2:1556344657609
run!username= pool-1-thread-4:1556344659607
run!username= pool-1-thread-5:1556344659607
run!username= pool-1-thread-1:1556344659607
run!username= pool-1-thread-3:1556344659610

再看remove()方法

public class Test {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
	 ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
	 Runnable runnable1 = new MyRunnable("A");
	 Runnable runnable2 = new MyRunnable("B");
	
	 ScheduledFuture future1 = executor.scheduleAtFixedRate(runnable1, 10, 2, TimeUnit.SECONDS);
	 Thread.sleep(1000);
	 ScheduledFuture future2 =executor.scheduleAtFixedRate(runnable2, 10, 2, TimeUnit.SECONDS);
	 Thread.sleep(5000);
	 //注意：remove()方法的参数是ScheduleFuture数据类型
	 System.out.println(executor.remove((Runnable)future2));
	 BlockingQueue<Runnable> queue = executor.getQueue();
	 Iterator<Runnable> iterator = queue.iterator();
	 while(iterator.hasNext()) {
		 Runnable runnable = (Runnable)iterator.next();
		 System.out.println("队列中的"+runnable);
	 }
  }
}
运行结果：
true
队列中的java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask@49097b5d[Not completed, task = java.util.concurrent.Executors$RunnableAdapter@4783da3f[Wrapped task = cn.yu.scheduledexecutorservice.MyRunnable@378fd1ac]]
run!username=A pool-1-thread-1:1556345263396
run!username=A pool-1-thread-1:1556345265395
run!username=A pool-1-thread-1:1556345267395
run!username=A pool-1-thread-1:1556345269395
run!username=A pool-1-thread-1:1556345271395
run!username=A pool-1-thread-1:1556345273396
run!username=A pool-1-thread-1:1556345275396
run!username=A pool-1-thread-1:1556345277396
run!username=A pool-1-thread-1:1556345279395
run!username=A pool-1-thread-1:1556345281395
run!username=A pool-1-thread-1:1556345283395
run!username=A pool-1-thread-1:1556345285395

8.7 方法setExecuteExistingDelayedTasksAfterShutdownPolicy()

方法setExecuteExistingDelayedTasksAfterShutdownPolicy(）的作用是当对ScheduledThreadPoolExecutor执行了shutdown()方法时，任务是否继续运行，默认值是true,也就是当调用了shutdown()方法时任务还是继续运行，当使用setExecuteExistingDelayedTasksAfterShutdownPolicy(false)时任务不再运行。

方法setExecuteExistingDelayedTasksAfterShutdownPolicy()可以与schedule()与shutdown()方法联合使用，但setExecuteExistingDelayedTasksAfterShutdownPolicy()方法不能与scheduleAtFixedRate(）和scheduleWithFixedDelay(）方法联合使用。那么如果想要实现shutdown关闭线程池后，池中的任务还会继续重复运行，则要将scheduleAtFixedRate()和scheduleWithFixedDelay()方法与setContinueExistingPeriodicTasksAfterShutdownPolicy()

8.8 方法setContinueExistingPeriodicTasksAfterShutdownPolicy()

方法setContinueExistingPeriodicTasksAfterShutdownPolicy(）传入true的作用是当使用scheduleAtFixedRate()方法或scheduleWithFixedDelay()方法时，如果调用ScheduledThreadPoolExecutor对象的shutdown()方法，任务还会继续运行，传入false时任务不运行，进程销毁。
8.9 使用cancel(boolean)与setRemoveOnCancelPolicy()方法
方法cancel(boolean) 的作用设定是是否取消任务
（当执行cancel（）方法后任务虽然被成功取消，但还是在队列中存在。再队列中的任务被取消后，任务也不再运行。）

ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10);
//将任务放入队列中1s后执行
ScheduledFutrue future = executor.schedule(runnable,1,TimeUnit,SECONDS);
//不将任务放入队列中，直接执行
ScheduledFutrue future = executor.schedule(runnable,0,TimeUnit,SECONDS);
正在执行的任务，调用了cancel()方法结合if(Thread.currentThread().isInterrupted() == true)
判断时，是可以让任务结束

总结：
1.在队列中的任务可以取消，任务也不再执行
2.正在运行的任务可以停在，但要结合if（Thread.currentThread().isInterrupted() == true）判断

方法setRemoveOnCancelPolicy(boolean)的作用设定是否将取消后的任务从队列中清除。
()

ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10);
ScheduledFuture future = executor.schedule(runnable,1,TimeUnit.SECONDS);
executor.setRemoveOnCancelPolicy(true);
executor.cancel(true);
setRemoveOnCancelPolicy()与cancel()方法结合，队列中的任务被删除。

本章总结：
本章介绍了基于线程池ThreadPoolExecutor的ScheduledThreadPoolExecutor计划任务执行池对象，使用此类可以高效地实现计划任务线程池，不在重复创建Thread对象，提高了运行效率。此类也支持间隔运行的功能。

迷糊弟弟
关注
专栏目录
【项目实战】并发编程之ScheduledExecutorService，Java提供的一个定时任务框架
本本本添哥
04-17 475
ScheduledExecutorService是Java提供的一个定时任务框架它可以用于调度任务的执行时间和频率。在Java中，ScheduledExecutorService是一个接口，ScheduledThreadPoolExecutor是它的一个实现类。ScheduledThreadPoolExecutor提供了一些额外的功能可以设置线程池的大小可以设置任务的超时时间等。如果您需要使用这些额外的功能，可以使用ScheduledThreadPoolExecutor。
Java并发编程实践-ScheduledExecutorService替换Timer
qq_42938846的博客
01-17 744
《Java并发编程实践》建议将使用Timer执行延迟执行和周期执行的任务换成ScheduledExecutorService来完成。原因如下： 1）Timer使用单线程来执行所有的timer任务，效率低下； 2）由于是单线程的，所以如果其中一个timer很耗时，将会导致其他TimerTask的失效性出现问题，简单的说，如果在A任务执行的过程中，B也到执行的时间点了，但是A没有执行完，所有B会等待A...
e_ScheduledExecutorService_基本使用-20210227
守望者的救赎
02-27 247
基本说明 JDK1.5 继承实现关系 在java.util.concurrent中为创建这些接口实例提供了一个综合性的工厂类Executors，有许多静态工厂方法用来构建线程池。 执行者工厂方法 方法 描述 newCachedThreadPool(…):ExecutorService 创建新线程；空闲线程会被保留60秒 newFixedThreadPool:ExecutorService 该池包含固定数量的线程；空闲线程会一直被保留 newSingleThreadExecutor:
ScheduledExecutorService定时周期执行指定的任务
zhangsheXIN_的专栏
11-11 1402
一：简单说明 ScheduleExecutorService接口中有四个重要的方法，其中scheduleAtFixedRate和scheduleWithFixedDelay在实现定时程序时比较方便。 下面是该接口的原型定义 java.util.concurrent.ScheduleExecutorService extends ExecutorService extends 
多线程学习｜ScheduledExecutorService 详解
最新发布
weixin_44435110的博客
07-21 1244
是 Java 中用于调度任务的执行器服务，它允许在给定的延迟后或定期执行任务。相比于Timer和TimerTask提供了更灵活和强大的功能，并能更好地处理多线程环境下的任务调度。
ScheduledExecutorService执行周期性或定时任务
lzhw1985的专栏
12-09 290
ScheduledExecutorService扩展了ExecutorService接口，提供时间排程的功能。   schedule(Callable&lt;V&gt; callable, long delay, TimeUnit unit)          创建并执行在给定延迟后启用的 ScheduledFuture。 schedule(Runnable command, long ...
Java多线程的ScheduledExecutorService使用
qq_1763467007的博客
04-04 8422
ScheduledExecutorService使用（一）定时任务的几种方案介绍（二）ScheduledExecutorService介绍（三）ScheduledExecutorService的使用3.1 schedule()使用 （一）定时任务的几种方案介绍 使用java做一个后台的定时任务，方案可以有如下几种： 1、JDK自带的Timer 2、JDK1.5+ 新增的ScheduledExecutorService 3、Quartz ：简单却强大的JAVA作业调度框架，可以支持动态的Cron语法 （二）S
Java ScheduledExecutorService
cxmfzu的博客
08-21 590
ScheduledExecutorService 简介 ScheduledExecutorService 的主要功能是将定时任务与线程池结合使用，网络上有很多博客对ScheduledExecutorService进行了分析，同时与Timer进行的比对。因此本篇不在对此进行描述，本篇主要描述使用ScheduledExecutorService的注意事项。 ScheduledExecutorService 代码原型 ScheduledExecutorService的构造函数源码是 public Schedule
java并发编程实战源码-JavaConcurrentProgramming:《Java并发编程实战》
05-25
《Java并发编程实战》是Java开发者深入理解并发编程的一本经典著作。这本书涵盖了Java多线程和并发库的广泛主题，旨在帮助读者掌握如何在Java环境中有效地设计和实现并发程序。源码JavaConcurrentProgramming-master...
java并发编程艺术源码-ArtConcurrentBook:《Java并发编程的艺术》
05-25
《Java并发编程的艺术》是一本深入探讨Java多线程与并发编程的经典著作，它涵盖了Java并发编程中的核心概念和技术。源码ArtConcurrentBook提供了书中示例代码的详细实现，对于学习和理解Java并发编程有着极大的帮助...
java ScheduledExecutorService 使用
pingnanlee的专栏
03-08 771
ScheduledExecutorService的作用是任务的调动和时间密切相关。最常用的两个方法分别是ScheduleAtFixedRate 和 ScheduleWithFixedDelay，这个两个方法在使用上还是有一些差别的。 ScheduleAtFixedRate，它是线程的执行以一个固定的频率执行，但是需要注意的是，当线程的执行频率快于线程的执行速度，这时下一个线程的执行仍然需要等待当前
【Java】定时器ScheduledExecutorService
qq_53070263的博客
02-23 4017
ScheduledExecutorService是一个定时器，可以用来将任务安排在指定的时间后执行，或者周期性的执行一个任务。
java 计划任务
yichudu
06-02 964
有一些程序是永不停歇的，比如监控某个数据表中的内容是否变化。若有变化通知给其他程序。下面两个类可以作为模版。 /** * 定期检查某个数据库中某表中的数据是否有变，若有更新，做想做的事。这是抽象基类。 * 泛型V代表 表中 每一行数据对应的对象。 */ import org.slf4j.Logger; import org.slf4j.LoggerFactory; impo
轻便型定时任务ScheduledExecutorService的简单使用
weixin_39596725的博客
08-14 308
ScheduledExecutorService简单使用 最近发现使用ScheduledExecutorService来解决一些任务周期性调度比较简便。而且是基于线程池设计的定时任务类，每个调度任务都会分配到线程池中的一个线程去执行。这里来记录一下使用方法跟碰到的问题。 package com.oracle.demo; import java.util.Date; import java.ut...
Java并发——ScheduledExecutorService
吴声子夜歌的博客
06-24 2814
ScheduledExecutorService 类 Scheduledexecutor Service的主要作用就是可以将定时任务与线程池功能结合使用。 ScheduledThreadPoolExecutor使用Callable延迟运行 public class MyCallableAA implements Callable<String> { @Override public String call() throws Exception { try {
ScheduledExecutorService的用法
weixin_37370093的博客
02-10 438
 一、ScheduledExecutorService 设计思想 ScheduledExecutorService,是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。 需要注意,只有当调度任务来的时候,ScheduledExecutorService才会真正启动一个线程,其余时间ScheduledExecutorServic
Java ScheduledExecutorService教程
Ricky
08-11 2958
参考资料https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ScheduledExecutorService.html
Java定时任务-ScheduledExecutorService
weixin_43911286的博客
01-27 1199
1.ScheduledExecutorService的接口介绍 package java.util.concurrent; public interface ScheduledExecutorService extends ExecutorService { //单次执行，在指定延时delay后运行command任务 public ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值