周期性线程池newScheduledThreadPool详解

最新推荐文章于 2024-05-02 11:21:05 发布
最新推荐文章于 2024-05-02 11:21:05 发布
阅读量4.3w 收藏 37
点赞数 8
分类专栏： # 【Java多线程】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuchangjie0112/article/details/90698401
版权

线程池支持定时以及周期性执行任务，创建一个corePoolSize为传入参数，最大线程数为整形的最大数的线程池

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
ScheduledThreadPoolExecutor类的构造：
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
              new DelayedWorkQueue());
    }
此线程池keepAliveTime参数为0，缓存对列为DelayedWorkQueue。
jdk1.5之前的版本中更多的是借助Timer类来实现，Timer和ScheduledThreadPoolExecutor的区别：

a.Timer单线程运行，一旦任务执行缓慢，下一个任务就会推迟，而如果使用了ScheduledThreadPoolExecutor线程数可以自行控制

b.当Timer中的一个任务抛出异常时，会导致其他所有任务不在执行

c.ScheduledThreadPoolExecutor可执行异步的任务，从而得到执行结果

ScheduledExecutorService接口继承了ExecutorService，在ExecutorService的基础上新增了以下几个方法：

①schedule方法：

public ScheduledFuture<?> schedule(Runnable command,
                       long delay, TimeUnit unit);
command：执行的任务 Callable或Runnable接口实现类
delay：延时执行任务的时间

unit：延迟时间单位

示例：


        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        ScheduledFuture<String> scheduledFuture = executorService.schedule(new Callable<String>() {
            public String call() throws Exception {
                return "call";
            }
        }, 10, TimeUnit.SECONDS);
        System.out.println(scheduledFuture.get());
        executorService.shutdown();
延迟10秒后，返回call字符串并输出。

执行任务案例：

package com.thread.testExtendsThread.fourPackage;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Queue;
import java.util.concurrent.*;

/**
 * @author liuchj
 * @version 1.0
 * @className ScheduleThreadTest
 * @description //TODO
 * @date 2019/5/30
 **/
public class ScheduleThreadTest {
    /**
     * 线程安全的队列
     */
    static Queue<String> queue = new ConcurrentLinkedQueue<String>();

    static {
        //入队列
        for (int i = 0; i < 9; i++) {
            queue.add("task-" + i);
        }
    }
    public static void main(String[] args) throws Exception {
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        for (int i = 0; i < queue.size(); i++) {
            ScheduledFuture<String> scheduledFuture = executorService.schedule(new Callable<String>() {
                @Override
                public String call() throws Exception {
                    String value = ThreadPoolTask.queue.poll();
                    if (value != "" && null != value) {
                        System.out.println("时间:" + sdf.format(new Date())+"线程" + Thread.currentThread().getName() + " 执行了task: " + value);
                    }
                    return "call";
                }
            }, 3, TimeUnit.SECONDS);

            System.out.println(scheduledFuture.get());
        }

        executorService.shutdown();
    }
}

执行结果：

时间:2019-05-30 03:53:11线程pool-1-thread-1 执行了task: task-0
call
时间:2019-05-30 03:53:14线程pool-1-thread-1 执行了task: task-1
call
时间:2019-05-30 03:53:17线程pool-1-thread-1 执行了task: task-2
call
时间:2019-05-30 03:53:20线程pool-1-thread-1 执行了task: task-3
call
时间:2019-05-30 03:53:23线程pool-1-thread-1 执行了task: task-4
call
时间:2019-05-30 03:53:26线程pool-1-thread-1 执行了task: task-5
call
时间:2019-05-30 03:53:29线程pool-1-thread-1 执行了task: task-6
call
时间:2019-05-30 03:53:32线程pool-1-thread-1 执行了task: task-7
call
Disconnected from the target VM, address: '127.0.0.1:59247', transport: 'socket'
时间:2019-05-30 03:53:35线程pool-1-thread-1 执行了task: task-8
call

②scheduleAtFixedRate方法：


 public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                          long initialDelay,
                          long period,
                          TimeUnit unit);
command：执行的任务 Callable或Runnable接口实现类

initialDelay：第一次执行任务延迟时间

period：连续执行任务之间的周期，从上一个任务开始执行时计算延迟多少开始执行下一个任务，但是还会等上一个任务结束之后。
unit：initialDelay和period时间单位

示例： 注意看输出结果


final SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);
        executorService.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("时间:" + sf.format(new Date()) );
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },  2, 3, TimeUnit.SECONDS);
输出结果： 
时间:2014-04-01 23:44:48
时间:2014-04-01 23:44:53
时间:2014-04-01 23:44:58
时间:2014-04-01 23:45:03

执行任务案例：

public class ScheduledThreadTest {
    /**
     * 线程安全的队列
     */
    static Queue<String> queue = new ConcurrentLinkedQueue<String>();

    static {
        //入队列
        for (int i = 0; i < 9; i++) {
            queue.add("task-" + i);
        }
    }

    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println("时间:" + sdf.format(new Date()) );
        for (int i = 0; i < queue.size(); i++) {
            executor.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {

                    String value = ThreadPoolTask.queue.poll();
                    if (value != "" && null != value) {
                        System.out.println("时间:" + sdf.format(new Date())+" 线程" + Thread.currentThread().getName() + " 执行了task: " + value);
                    }
                    try {
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },  2, 6, TimeUnit.SECONDS);

        }
//不注释这行会打印出问题，应该是先执行关闭线程操作了
//        executor.shutdown();
    }
}

执行结果：

时间:2019-05-30 03:33:19
时间:2019-05-30 03:33:21 线程pool-1-thread-2 执行了task: task-0
时间:2019-05-30 03:33:21 线程pool-1-thread-1 执行了task: task-1
时间:2019-05-30 03:33:26 线程pool-1-thread-2 执行了task: task-2
时间:2019-05-30 03:33:26 线程pool-1-thread-1 执行了task: task-3
时间:2019-05-30 03:33:31 线程pool-1-thread-2 执行了task: task-4
时间:2019-05-30 03:33:31 线程pool-1-thread-1 执行了task: task-5
时间:2019-05-30 03:33:36 线程pool-1-thread-2 执行了task: task-6
时间:2019-05-30 03:33:36 线程pool-1-thread-1 执行了task: task-7
时间:2019-05-30 03:33:40 线程pool-1-thread-2 执行了task: task-8

 

③scheduleWithFixedDelay方法：

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                             long initialDelay,
                             long delay,
                             TimeUnit unit);
command：执行的任务 Callable或Runnable接口实现类

initialDelay：第一次执行任务延迟时间
period：连续执行任务之间的周期，从上一个任务全部执行完成时计算延迟多少开始执行下一个任务
unit：initialDelay和period时间单位

final SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        executor.scheduleWithFixedDelay(new Runnable() {
            public void run() {
                System.out.println("时间:" + sf.format(new Date()) );
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },  2, 3, TimeUnit.SECONDS);
输出结果： 
时间:2014-04-01 23:47:38
时间:2014-04-01 23:47:46
时间:2014-04-01 23:47:54

执行任务案例：

package com.thread.testExtendsThread.fourPackage;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Queue;
import java.util.concurrent.*;

/**
 * @author liuchj
 * @version 1.0
 * @className ScheduledThreadTest
 * @description //TODO
 * @date 2019/5/30
 **/
public class ScheduledThreadTest {
    /**
     * 线程安全的队列
     */
    static Queue<String> queue = new ConcurrentLinkedQueue<String>();

    static {
        //入队列
        for (int i = 0; i < 9; i++) {
            queue.add("task-" + i);
        }
    }

    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println("时间:" + sdf.format(new Date()) );
        for (int i = 0; i < queue.size(); i++) {
            executor.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {

                    String value = ThreadPoolTask.queue.poll();
                    if (value != "" && null != value) {
                        System.out.println("时间:" + sdf.format(new Date())+" 线程" + Thread.currentThread().getName() + " 执行了task: " + value);
                    }
                    try {
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },  2, 6, TimeUnit.SECONDS);

        }
//这行代码不注释掉，任务都不能执行了，估计先执行此处关闭线程
//        executor.shutdown();
    }
}

执行结果：

时间:2019-05-30 03:54:45
时间:2019-05-30 03:54:47 线程pool-1-thread-2 执行了task: task-1
时间:2019-05-30 03:54:47 线程pool-1-thread-1 执行了task: task-0
时间:2019-05-30 03:54:52 线程pool-1-thread-1 执行了task: task-2
时间:2019-05-30 03:54:52 线程pool-1-thread-2 执行了task: task-3
时间:2019-05-30 03:54:57 线程pool-1-thread-2 执行了task: task-4
时间:2019-05-30 03:54:57 线程pool-1-thread-1 执行了task: task-5
时间:2019-05-30 03:55:02 线程pool-1-thread-1 执行了task: task-6
时间:2019-05-30 03:55:02 线程pool-1-thread-2 执行了task: task-7
时间:2019-05-30 03:55:07 线程pool-1-thread-1 执行了task: task-8


 

痴书先生
关注
  • 8
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
周期性线程池newScheduledThreadPool讲解
weixin_52028697的博客
07-26 1677
a.Timer是单线程运行，一旦任务执行缓慢，下一个任务就会推迟，而如果使用了ScheduledThreadPoolExecutor线程数可以自行控制。System.out.println("程序开始时间"+sdf.format(newDate()));System.out.println("程序结束时间"+sdf.format(newDate()));//程序开始执行了,这是一个主方法,所以是主线程。//最后执行结果是主线程先执行完,子线程才会执行。//这边newTask()是一个子线程。...
java线程池之newScheduledThreadPool
qq_40308101的博客
03-26 6427
1、特点： 延时启动 、定时启动 、可以自定义最大线程池数量 2、创建实例： ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3); 这里如果没有特殊需求要指定最大线程池数量的话，建议最大线程池数量=运行程序机器的cpu核心数，即 int cpuNubmer = Run...
newScheduledThreadPool创建线程池学习
努力改变人生
09-16 603
schedule方法（首次执行延迟delay秒执行） package com.glch.threads; import java.text.SimpleDateFormat; import java.util.Date; import java.util.concurrent.Callable; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; impo.
周期性线程池 newScheduledThreadPool
张紫娃的博客
05-21 2046
【代码】周期性线程池 newScheduledThreadPool。
Java并发newScheduledThreadPool()方法
最新发布
unber的博客
05-02 192
可以通过调用Executors类的方法获得一个调度的线程池。Java。
java线程池（四）之newScheduledThreadPool
weixin_44613100的博客
06-07 1116
newScheduledThreadPool测试类 package com.thread.pool; import java.util.Date; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class TestScheduledPool { public stat
Java并发包：ScheduledExecutorService
charming的专栏
07-14 7700
文章译自：http://tutorials.jenkov.com/java-util-concurrent/index.html 抽空翻译了一下这个教程的文章，后面会陆续放出，如有不妥，请批评指正。 转自请注明出处。ScheduledExecutorServicejava.util.concurrent.ScheduleExecutorService是一种安排任务执行的ExecutorSer
并发编程 定时线程池ScheduledThreadPoolExecutor学习总结
weixin_45161367的博客
07-23 606
并发编程 定时线程池ScheduledThreadPoolExecutor学习总结
Thread的setDaemon(true)方法的作用
热门推荐
02-09 5万+
定义：守护线程--也称“服务线程”，在没有用户线程可服务时会自动离开。优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。 设置：通过setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护线程的方式是在 线程对象创建 之前 用线程对象的setDaemon方法。 example: 垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的Thr
Java线程池技术详解
06-14
线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还...
多线程与线程池技术详解（图书配套）
07-01
本套视频为同名图书的配套视频，图书预计在2021.4上市
多线程与线程池技术详解
06-12
在当前的Java面试和后台开发中，多线程与线程池技术越来越重要。毫不夸张的说，如何你想进入任何一家好的网络公司并能够长足发展，多线程与线程池技术是必须要掌握的技能！
jdk自带线程池实例详解
08-28
jdk自带线程池实例详解 jdk自带的线程池是Java开发中一个非常重要的概念，特别是在多线程编程中。线程池是线程的容器，每次只执行额定数量的线程，线程池就是用来管理这些额定数量的线程。下面我们来详细了解jdk...
Python定时器线程池原理详解
01-20
这篇文章主要介绍了Python定时器线程池原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 定时器执行循环任务： 知识储备 Timer(interval, function, ...
Java线程池原理
Jasper的博客
12-14 149
线程池的优点 1、线程是稀缺资源，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以重复使用。 2、可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多内存导致服务器崩溃。 Executor 框架与线程池 在 Java 5 之后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor 框架便是 Java 5 中引入的，其内部使用了线程池机制， 它在 jav...
面试官：详谈Java四种线程池及new Thread的弊端
Java烂猪皮
05-31 1424
执行异步任务只是如下吗？那你就太out了，new Thread的弊端如下：1）每次通过创建对象性能不佳。2）线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。3）缺乏更多功能，如定时执行、定期执行、线程中断。相比提供的四种线程池的好处在于：1）重用存在的线程，减少对象创建、消亡的开销，提升性能。2）可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
ScheduledThreadPoolExecutor 及 ThreadPoolExecutor的基本使用及说明
fumeidonga的博客
07-29 1790
ScheduledThreadPoolExecutor 及 ThreadPoolExecutor
线程池原理
huidev的博客
01-06 212
多线程是开发常用的技术，Android 开发更是对UI 线程进行了限制，耗时操作必须放到子线程，new Thread 很简单就创建了一个子线程，但如果大型项目，很多地方都new Thread ，那么有一个问题就是我们将无法管理我的线程，大量的创建线程，占用过多资源，而且它们之间也会相互竞争，还有就是创建线程与线程执行完的销毁操作都是一部分系统开销。所以引入线程池很有意义。 描述 ...
Java四种线程池newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor
ws6013480777777的博客
11-04 707
1、new Thread的弊端 执行一个异步任务你还只是如下new Thread吗？ newThread(newRunnable() { @Override publicvoidrun() { // TODO Auto-generated method stub } }).start(); 那你就out太多了，new Thread的弊端如下： a....
java线程池参数详解
02-28
Java线程池是一种用于管理和复用线程的机制，它可以提高多线程程序的性能和效率。在Java中，线程池由ThreadPoolExecutor类实现，通过设置不同的参数可以对线程池的行为进行调整。 以下是Java线程池的一些常用参数及其解释： 1. corePoolSize（核心线程数）：线程池中始终保持的活动线程数，即使它们处于空闲状态。当有新任务提交时，如果活动线程数小于corePoolSize，则会创建新线程来处理任务。 2. maximumPoolSize（最大线程数）：线程池中允许存在的最大线程数。当活动线程数达到maximumPoolSize并且工作队列已满时，新任务将会被拒绝。 3. keepAliveTime（线程空闲时间）：当线程池中的线程数量超过corePoolSize时，多余的空闲线程在等待新任务到来时的最长等待时间。超过这个时间，空闲线程将被终止。 4. unit（时间单位）：keepAliveTime的时间单位，可以是秒、毫秒、微秒等。 5. workQueue（工作队列）：用于存储等待执行的任务的阻塞队列。常见的工作队列有ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。 6. threadFactory（线程工厂）：用于创建新线程的工厂类。可以自定义线程的名称、优先级等属性。 7. handler（拒绝策略）：当线程池无法接受新任务时的处理策略。常见的拒绝策略有AbortPolicy（默认，抛出RejectedExecutionException异常）、CallerRunsPolicy（由调用线程执行任务）、DiscardPolicy（直接丢弃任务）和DiscardOldestPolicy（丢弃最旧的任务）。 这些参数可以根据实际需求进行调整，以达到最佳的线程池性能和资源利用率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

痴书先生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值