Java ScheduledThreadPoolExecutor延迟或周期性执行任务

摘要:
之前,我写过一篇关于JavaThreadPoolExecutor的文章,它使用Executor创建线程池。Executors类还提供了一个工厂方法来创建ScheduledThreadPoolExecutor,并可以在线程池中设置线程。scheduledThreadPool.isTerminated()){//等待所有任务完成}System.out.println;}}运行上述程序以获得以下输出,这可以确认任务在10秒后才会执行。ScheduledFuture接口继承Future接口。有关详细信息,请参阅JavaCallableFutureExample。ScheduledExecutorService中至少有两个方法可用于定期执行任务。ScheduleAtFixedRate我们可以使用此方法延迟任务执行并设置任务执行周期。

Java提供的Time类可以周期性地或者延期执行任务,但是有时我们需要并行执行同样的任务,这个时候如果创建多个Time对象会给系统带来负担,解决办法是将定时任务放到线程池中执行。

Java的ScheduledThreadPoolExecutor类实现了ScheduledExecutorService接口中定义的以不同方法执行任务的方法。

之前,我写过一篇关于Java ThreadPoolExecutor的文章中使用了Executors创建线程池。Executors类也提供了工厂方法创建ScheduledThreadPoolExecutor,并且可以设置线程池中的线程。

假设有下面简单的Runnable类

WorkerThread.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.journaldev.threads;
 
import java.util.Date;
 
public classWorkerThread implementsRunnable{
 
private String command;
 
    publicWorkerThread(String s){
        this.command=s;
    }
 
    @Override
    publicvoidrun() {
        System.out.println(Thread.currentThread().getName()+" Start. Time = "+newDate());
        processCommand();
        System.out.println(Thread.currentThread().getName()+" End. Time = "+newDate());
    }
 
    privatevoidprocessCommand() {
        try{
            Thread.sleep(5000);
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    @Override
    publicString toString(){
        returnthis.command;
    }
}

下面的例子中worker线程将被延期10s执行上面的Rnnable类大约花费5s执行任务

ScheduledThreadPool.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.journaldev.threads;
 
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
public classScheduledThreadPool {
 
    publicstaticvoid main(String[] args) throws InterruptedException {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
 
        //schedule to run after sometime
        System.out.println("Current Time = "+newDate());
        for(inti=0; i<3; i++){
            Thread.sleep(1000);
            WorkerThread worker = newWorkerThread("do heavy processing");
            scheduledThreadPool.schedule(worker, 10, TimeUnit.SECONDS);
        }
 
        //add some delay to let some threads spawn by scheduler
        Thread.sleep(30000);
 
        scheduledThreadPool.shutdown();
        while(!scheduledThreadPool.isTerminated()){
            //wait for all tasks to finish
        }
        System.out.println("Finished all threads");
    }
 
}

运行上面的程序,可以得到下面的输出,由此可以确认任务在10s后才执行。

1
2
3
4
5
6
7
8
Current Time = Tue Oct 29 15:10:03 IST 2013
pool-1-thread-1 Start. Time = Tue Oct 29 15:10:14 IST 2013
pool-1-thread-2 Start. Time = Tue Oct 29 15:10:15 IST 2013
pool-1-thread-3 Start. Time = Tue Oct 29 15:10:16 IST 2013
pool-1-thread-1 End. Time = Tue Oct 29 15:10:19 IST 2013
pool-1-thread-2 End. Time = Tue Oct 29 15:10:20 IST 2013
pool-1-thread-3 End. Time = Tue Oct 29 15:10:21 IST 2013
Finished all threads

注意到所有的schedule方法都返回了ScheduledFuture实例,可以用于获取线程状态信息和延迟时间。ScheduledFuture接口继承Future接口,更多信息见Java Callable Future Example.

在ScheduledExecutorService中至少有2个方法可用于周期性执行任务。

scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)

我们可以使用该方法延迟执行任务,设置任务的执行周期。时间周期从线程池中首先开始执行的线程算起,所以假设period为1s,线程执行了5s,那么下一个线程在第一个线程运行完后会很快被执行。

比如下面的代码

1
2
3
4
5
6
for (inti = 0; i < 3; i++) {
    Thread.sleep(1000);
    WorkerThread worker = newWorkerThread("do heavy processing");
    // schedule task to execute at fixed rate
    scheduledThreadPool.scheduleAtFixedRate(worker, 0, 10,
            TimeUnit.SECONDS);
输出
1
2
3
4
5
6
7
8
9
Current Time = Tue Oct 29 16:10:00 IST 2013
pool-1-thread-1 Start. Time = Tue Oct 29 16:10:01 IST 2013
pool-1-thread-2 Start. Time = Tue Oct 29 16:10:02 IST 2013
pool-1-thread-3 Start. Time = Tue Oct 29 16:10:03 IST 2013
pool-1-thread-1 End. Time = Tue Oct 29 16:10:06 IST 2013
pool-1-thread-2 End. Time = Tue Oct 29 16:10:07 IST 2013
pool-1-thread-3 End. Time = Tue Oct 29 16:10:08 IST 2013
pool-1-thread-1 Start. Time = Tue Oct 29 16:10:11 IST 2013
pool-1-thread-4 Start. Time = Tue Oct 29 16:10:12 IST 2013
scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit)
该方法可被用于延迟周期性执行任务,delaytime是线程停止执行到下一次开始执行之间的延迟时间,假设有下面的代码
1
2
3
4
5
6
for (inti = 0; i < 3; i++) {
    Thread.sleep(1000);
    WorkerThread worker = newWorkerThread("do heavy processing");
    scheduledThreadPool.scheduleWithFixedDelay(worker, 0, 1,
            TimeUnit.SECONDS);
}
输出结果
1
2
3
4
5
6
7
8
9
Current Time = Tue Oct 29 16:14:13 IST 2013
pool-1-thread-1 Start. Time = Tue Oct 29 16:14:14 IST 2013
pool-1-thread-2 Start. Time = Tue Oct 29 16:14:15 IST 2013
pool-1-thread-3 Start. Time = Tue Oct 29 16:14:16 IST 2013
pool-1-thread-1 End. Time = Tue Oct 29 16:14:19 IST 2013
pool-1-thread-2 End. Time = Tue Oct 29 16:14:20 IST 2013
pool-1-thread-1 Start. Time = Tue Oct 29 16:14:20 IST 2013
pool-1-thread-3 End. Time = Tue Oct 29 16:14:21 IST 2013
pool-1-thread-4 Start. Time = Tue Oct 29 16:14:21 IST 2013

免责声明:文章转载自《Java ScheduledThreadPoolExecutor延迟或周期性执行任务》仅用于学习参考。如对内容有疑问,请及时联系本站处理。

上篇PHP设计模式(三)抽象工厂模式(Abstract Factory For PHP)Java使用Robot操作键盘和鼠标下篇

宿迁高防,2C2G15M,22元/月;香港BGP,2C5G5M,25元/月 雨云优惠码:MjYwNzM=

相关文章

【STM32H7】第3章 ThreadX操作系统介绍

论坛原始地址(持续更新):http://www.armbbs.cn/forum.php?mod=viewthread&tid=99514 第3章   ThreadX操作系统介绍 本章节介绍 ThreadX 操作系统,让大家对 ThreadX 有一个整体的了解。 3.1 初学者重要提示 3.2 Express Logic公司介绍 3.3 ThreadX...

操作系统-用户级线程

1. 多进程是操作系统的基本图像 2. 是否可以资源不动而切换指令序列 两个函数共享同一份数据的时候,可以用线程来运行它们,想java里面的多线程就行 把进程的切换分成两个部分,一个是指令的切换,一个是映射表(内存)的切换,现在只需知道指令的切换,也就是线程的切换 3. 切换线程是否实用? 4. 如何实现(重点) 主要靠Yield来实现切换其作用是...

Java内存模型(JMM)总结

Java内存模型(JMM) 我们常说的JVM内存模型指的是JVM的内存分区;而Java内存模型是一种虚拟机规范。 Java虚拟机规范中定义了Java内存模型(Java Memory Model,JMM),用于屏蔽掉各种硬件和操作系统的内存访问差异,实现让Java程序在各种平台下都能达到一致的并发效果,JMM规范了Java虚拟机与计算机内存是如何协同工作的:...

什么是高并发?

一、什么是高并发 ​ 高并发(High Concurrency)是一种系统运行过程中遇到的一种“短时间内遇到大量操作请求”的情况,主要发生在web系统集中大量访问收到大量请求(例如:12306的抢票情况;天猫双十一活动)。该情况的发生会导致系统在这段时间内执行大量操作,例如对资源的请求、数据库的操作等。 二、高并发的处理指标 高并发相关常用的一些指标有:响...

由浅入深TheradLocal

线程并发:在多线程并发的场景下 传递数据:我们可以通过ThreadLocal在同一线程,不同组件中传递公共变量 线程隔离:每个线程的变量都是独立的,不会相互影响 常用方法 方法声明 描述 ThreadLocal() 创建ThreadLocal对象 public void set(T value) 设置当前线程绑定的局部变量 public...

java 注解结合 spring aop 实现日志traceId唯一标识

MDC 的必要性 日志框架 日志框架成熟的也比较多: slf4j log4j logback log4j2 我们没有必要重复造轮子,一般是建议和 slf4j 进行整合,便于后期替换为其他框架。 日志的使用 基本上所有的应用都需要打印日志,但并不是每一个开发都会输出日志。 主要有下面的问题: (1)日志太少,出问题时无法定位问题 (2)日志太多,查找问题很麻...