Java ScheduledThreadPoolExecutor 示例

最新推荐文章于 2024-05-23 16:34:49 发布
最新推荐文章于 2024-05-23 16:34:49 发布
阅读量803 收藏 2
点赞数
文章标签： java linq p2p
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allway2/article/details/124518491
版权

有多种方法可以在 java 中安排任务。我们已经有Java timer来安排任务，但是 timers 任务的问题是您一次只能执行一个任务。因此，如果当前任务需要更长的时间，后续作业将被延迟。

在这种情况下，您可以使用 Java ScheduledThreadPoolExecutor。这个类是 Executor 框架的一部分，它提供了安排任务而不是立即执行任务的工具。
您可以使用三种方法来使用 ScheduledThreadPoolExecutor 来安排任务。

Java ScheduledThreadPoolExecutor 示例：

第 1 步：创建一个名为“RunnableTask.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 org.arpit.java2blog;
 
import java.util.Date;
 
public class RunnableTask implements Runnable{
 
private String taskName;
 
    public RunnableTask(String s){
        this.taskName=s;
    }
 
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+" Start Time for "+taskName+" "+new Date());
        // Process task here
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+" End Time for "+taskName+" "+new Date());
    }
 
    @Override
    public String toString(){
        return this.taskName;
    }
}
 

第2步：

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
 
package org.arpit.java2blog;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
public class ScheduledThreadPoolMain {
 
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Current Time = "+new Date());
        // Created ScheduledThreadPoolExecutor object
 
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
 
        for(int i=1; i<=3; i++){
            Thread.sleep(2000);
            RunnableTask task = new RunnableTask("Task "+i);
            scheduledThreadPool.schedule(task,5, TimeUnit.SECONDS);
        }
 
        // Adding some delay
        Thread.sleep(10000);
 
        scheduledThreadPool.shutdown();
        System.out.println("Completed all threads");
    }
}
 

让我们更多地了解上述主要方法。

1
2
3
 
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
 

ScheduledThreadPoolExecutor 在 Executors 类中也有名为 newScheduledThreadPool 的工厂方法，类似于 newFixedThreadPoolExecutor 和 newCachedThreadPoolExectuor。
您需要调用 schedule 方法来安排任务。
schedule 方法接受三个参数：
public Sc​​heduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit):
Runnable command：表示要调度的任务。
长时间延迟：它表示您要安排任务的初始延迟。
TimeUnit 单位：延迟参数的时间度量。
如果您注意到，schedule 方法会返回 ScheduledFuture<?> 的对象，您可以使用它来获取已提交作业的状态。

我们也调用了scheduledThreadPool.shutdown()，shutdown()方法默认会等待提交的任务执行然后终止。您可以使用 setExecuteExistingDelayedTasksAfterShutdownPolicy() 更改此策略。

当你运行上面的程序时，你会得到下面的输出：

Current Time = Fri May 19 00:20:39 IST 2017
pool-1-thread-1 Start Time for Task 1 Fri May 19 00:20:46 IST 2017
pool-1-thread-2 Start Time for Task 2 Fri May 19 00:20:48 IST 2017
pool-1-thread-3 Start Time for Task 3 Fri May 19 00:20:50 IST 2017
pool-1-thread-1 End Time for Task 1 Fri May 19 00:20:51 IST 2017
pool-1-thread-2 End Time for Task 2 Fri May 19 00:20:53 IST 2017
pool-1-thread-3 End Time for Task 3 Fri May 19 00:20:55 IST 2017
Completed all threads

ScheduledThreadPoolExecutor 的 scheduleAtFixedRate 示例：

ScheduledThreadPoolExecutor 的 scheduleAtFixedRate 用于在修复延迟后调度任务，然后定期执行该任务。
scheduleAtFixedRate 方法有四个参数：
public Sc​​heduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit)
Runnable command：表示要调度的任务。
long initialDelay：它表示您要安排任务的初始延迟。
长周期：它表示您要重复任务的周期。
TimeUnit 单位：延迟参数的时间度量。
让我们做一些更改来调用 ScheduledThreadPoolMain 中的 scheduleAtFixedRate。

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
33
34
35
36
 
package org.arpit.java2blog;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
public class ScheduledThreadPoolMain {
 
    /**
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Current Time = "+new Date());
        // Created ScheduledThreadPoolExecutor object
 
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
 
        for(int i=1; i<=3; i++){
            Thread.sleep(2000);
            RunnableTask task = new RunnableTask("Task "+i);
            scheduledThreadPool.scheduleAtFixedRate(task,5,10,TimeUnit.SECONDS);
        }
 
        // Adding some delay
        Thread.sleep(15000);
 
        scheduledThreadPool.shutdown();
        while(!scheduledThreadPool.isTerminated()){
            //wait for all tasks to finish
        }
        System.out.println("Completed all threads");
    }
}
 

当你运行上面的程序时，你会得到下面的输出：

Current Time = Fri May 19 00:56:29 IST 2017
pool-1-thread-1 Start Time for Task 1 Fri May 19 00:56:36 IST 2017
pool-1-thread-2 Start Time for Task 2 Fri May 19 00:56:38 IST 2017
pool-1-thread-3 Start Time for Task 3 Fri May 19 00:56:40 IST 2017
pool-1-thread-1 End Time for Task 1 Fri May 19 00:56:41 IST 2017
pool-1-thread-2 End Time for Task 2 Fri May 19 00:56:43 IST 2017
pool-1-thread-3 End Time for Task 3 Fri May 19 00:56:45 IST 2017
pool-1-thread-1 Start Time for Task 1 Fri May 19 00:56:46 IST 2017
pool-1-thread-2 Start Time for Task 2 Fri May 19 00:56:48 IST 2017
pool-1-thread-3 Start Time for Task 3 Fri May 19 00:56:50 IST 2017
pool-1-thread-1 End Time for Task 1 Fri May 19 00:56:51 IST 2017
pool-1-thread-2 End Time for Task 2 Fri May 19 00:56:53 IST 2017
pool-1-thread-3 End Time for Task 3 Fri May 19 00:56:55 IST 2017
Completed all threads

如果仔细观察输出：

pool-1-thread-1 Start Time for Task 1 Fri May 19 00:56:36 IST 2017
pool-1-thread-1 Start Time for Task 1 Fri May 19 00:56:46 IST 2017

一旦任务 1 开始，下一个任务会在 scheduleAtFixedRate 方法中提供的 10 秒后安排。

ScheduledThreadPoolExecutor 的 scheduleWithFixedDelay 示例：

ScheduledThreadPoolExecutor 的 scheduleWithFixedDelay 用于在初始延迟后调度一个任务，然后在前一个任务完成后以固定延迟执行任务。
让我们做一些更改来调用 ScheduledThreadPoolMain 中的 scheduleWithFixedDelay。

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
33
34
35
36
 
package org.arpit.java2blog;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
public class ScheduledThreadPoolMain {
 
    /**
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        System.out.println("Current Time = "+new Date());
        // Created ScheduledThreadPoolExecutor object
 
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
 
        for(int i=1; i<=3; i++){
            Thread.sleep(2000);
            RunnableTask task = new RunnableTask("Task "+i);
            scheduledThreadPool.scheduleWithFixedDelay(task,5,10,TimeUnit.SECONDS);
        }
 
        // Adding some delay
        Thread.sleep(30000);
 
        scheduledThreadPool.shutdown();
        while(!scheduledThreadPool.isTerminated()){
            //wait for all tasks to finish
        }
        System.out.println("Completed all threads");
    }
}
  

Current Time = Fri May 19 00:20:39 IST 2017
Current Time = Fri May 19 00:50:53 IST 2017
pool-1-thread-1 Start Time for Task 1 Fri May 19 00:51:00 IST 2017
pool-1-thread-2 Start Time for Task 2 Fri May 19 00:51:02 IST 2017
pool-1-thread-3 Start Time for Task 3 Fri May 19 00:51:04 IST 2017
pool-1-thread-1 End Time for Task 1 Fri May 19 00:51:05 IST 2017
pool-1-thread-2 End Time for Task 2 Fri May 19 00:51:07 IST 2017
pool-1-thread-3 End Time for Task 3 Fri May 19 00:51:09 IST 2017
pool-1-thread-1 Start Time for Task 1 Fri May 19 00:51:15 IST 2017
pool-1-thread-2 Start Time for Task 2 Fri May 19 00:51:17 IST 2017
pool-1-thread-3 Start Time for Task 3 Fri May 19 00:51:19 IST 2017
pool-1-thread-1 End Time for Task 1 Fri May 19 00:51:20 IST 2017
pool-1-thread-2 End Time for Task 2 Fri May 19 00:51:22 IST 2017
pool-1-thread-3 End Time for Task 3 Fri May 19 00:51:24 IST 2017
Completed all threads

如果仔细观察输出：

pool-1-thread-1 End Time for Task 1 Fri May 19 00:51:05 IST 2017
pool-1-thread-1 Start Time for Task 1 Fri May 19 00:51:15 IST 2017

一旦任务 1 结束，下一个任务会在 scheduleWithFixedDelay 方法中提供的 10 秒延迟后安排。

这就是 Java ScheduledThreadPoolExecutor 示例的全部内容。

 

allway2
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ScheduledThreadPoolExecutor 学习笔记
西瓜游侠的博客
05-08 570
JDK 版本：AdoptOpenJDK 11.0.10+9 1 基本概念 ScheduledThreadPoolExecutor 是 j.u.c 内置的用于处理延时、周期性任务调度的线程池。它继承了 ThreadPoolExecutor 类同时实现了 ScheduledExecutorService 接口。 由于要满足任务的延时、周期调度，在 ScheduledThreadPoolExecutor 中会对所有 Runnable 任务进行包装，包装成一个 RunnableScheduledFut.
executor:Java 执行器示例
07-21
在`executor-master`这个项目中，我们很可能是看到一个使用Java执行器的示例代码，可能包含以下内容： 1. **线程池的创建**：通常使用`Executors`静态工厂方法来创建不同类型的线程池，如`newFixedThreadPool`...
【JUC并发编程】5 定时任务线程池ScheduledThreadPoolExecutor的使用
热门推荐
健身变秃，coding变强
08-09 1万+
ScheduledThreadPoolExecutor介绍 ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后执行任务，或者定期执行任务。通常使用工厂类Executors来创建。 ScheduledThreadPoolExecutor的功能与Timer类似，但比Timer更强大，更灵活，Timer对应的是单个后台线程，而ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。 2.Sc
ScheduledThreadPoolExecutor 周期性执行任务的线程池作用，基本使用，使用场景
最新发布
weixin_44131922的博客
05-23 495
是Java并发编程中一个非常实用的类，它是包下的一个线程池实现，专为定时或周期性任务执行而设计。它提供了灵活且强大的定时任务调度功能，相比传统的Timer类，它具备更好的并发控制能力和错误处理机制。
Java并发之ScheduleThreadPoolExecutor
ZCC的专栏
05-11 631
一、ScheduleThreadPoolExecutor 简介 ScheduledThreadPoolExecutor 扩展了 ThreadPoolExecutor 类，并且添加了其它方法实现了ScheduledExecutorService 接口。 schedule() 方法允许在指定的延迟后执行一次任务 scheduleAtFixedRate() 方法允许在指定的初始延迟后执行任务，然后以一定的周期重复执行，其中 period 参数用于指定两个任务的开始时间之间的间隔时间，因此任务执行的频率是固定
Java线程调度ScheduledThreadPoolExecutor简单使用样例
Zhang Phil
03-08 4045
Java线程调度ScheduledThreadPoolExecutor简单使用样例代码例子：package test; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class Test { private static class
Java多线程案例——线程池及ThreadPoolExecutor类
小小码农
01-11 2033
Java多线程案例——线程池及ThreadPoolExecutor类
java 定时器线程池（ScheduledThreadPoolExecutor）的实现
08-19
主要介绍了java 定时器线程池（ScheduledThreadPoolExecutor）,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java 线程池框架
08-31
本文将深入探讨Java线程池的结构、常见实现、示例以及其核心参数。 一、线程池结构 线程池通常由以下几个关键组件构成： 1. 工作队列（Work Queue）：存放待执行的任务，如ArrayBlockingQueue或...
threadmodel:java线程模型
05-18
1. **Java线程基础**：包括线程的创建、启动、同步控制（如synchronized、wait/notify、Lock接口等）以及线程池的使用（如ExecutorService、ThreadPoolExecutor和ScheduledThreadPoolExecutor）。 2. **BIO线程模型...
java在服务启动的时候启动定时器
09-20
通过实现此接口的类，如`ScheduledThreadPoolExecutor`，我们可以实现多线程定时任务调度。 ### 2.1 使用示例 ```java import java.util.concurrent.Executors; import java.util.concurrent....
Java 线程池 – ThreadPoolExecutor 示例
qq2981118661的博客
06-14 1290
为什么需要Java 中的线程池？答案通常是当您在 Java 中开发一个简单的并发应用程序时，您会创建一些`Runnable`对象，然后创建相应的`Thread`对象来执行它们。在 Java 中创建线程是一项昂贵的操作。而且如果你每次都开始创建新的线程实例来执行任务，应用程序的性能肯定会下降。...
单例模式的应用
重燃小窗
06-30 206
创建一个单例对象package com.myshiro.support.support.manager; import java.util.TimerTask; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; /* * * @Author xuzn ...
Java 线程池详解
杨宇昌的博客
04-22 988
线程池详解
秒懂 ScheduledThreadPoolExecutor
二师兄撒欢之地
01-13 128
ScheduledThreadPoolExecutor 扩展自 一文秒懂 Java 线程池之 ThreadPoolExecutor 讲解的 了ThreadPoolExecutor 类，并且添加了其它方法实现了 ScheduledExecutorService 接口。
(java并发)ScheduledThreadPoolExcutor
xiajie的专栏
03-20 7696
1.用timer缺点非常大 Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。 我们关于定时/周期操作都是通过Timer来实现的。但是Timer有以下几种危险 a. Timer是基于绝对时间的。容易受系统时钟的影响。  b. Timer只新建了一个
Java实战小技巧（一）：线程池ScheduledThreadPoolExecutor应用
The Blog of Coder
10-23 705
ScheduledThreadPoolExecutor 继承自 ThreadPoolExecutor，它主要用来在给定的延迟之后运行任务，或者定期执行任务。在实际应用中，可将ScheduledThreadPoolExecutor用于服务端异步处理HTTP请求，避免高并发导致阻塞。
ScheduledThreadPoolExecutor详解实战
weixin_43942106的博客
01-06 4644
ScheduledThreadPoolExecutor详解 简介 继承自ThreadPooExecutor,为任务提供延迟或周期执行. 使用专门的ScheduledFutureTask来执行周期任务,也可以接收不需要时间调度的任务. 使用DelayedWorkQueue存储任务.(一种无界延迟队列) 支持线程池关闭后可执行,可选择线程池关闭后支持继续执行周期或延迟任务. 解析 内部有两个内部类: ScheduledFutureTask:可以延迟执行的异步运算任务. DelayedWorkQueue:存
ScheduledThreadPool 浅析和例子
sweet_sauce的博客
03-04 880
我们知道Timer与TimerTask虽然可以实现线程的周期和延迟调度，但是Timer与TimerTask存在一些缺陷，所以对于这种定期、周期执行任务的调度策略，我们一般都是推荐ScheduledThreadPoolExecutor来实现。下面就深入分析ScheduledThreadPoolExecutor是如何来实现线程的周期、延迟调度的。 ScheduledThreadPoolExecuto...
java使用ScheduledThreadPoolExecutor并发执行
12-30
使用ScheduledThreadPoolExecutor可以实现Java中的并发执行。下面是一个使用ScheduledThreadPoolExecutor并发执行的示例： ```java import java.util.concurrent.Executors; import java.util.concurrent....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值