线程池newScheduledThreadPool使用

Posted 2023-03-15

参考技术A

newScheduledThreadPool是一个可以周期性执行任务的线程池

可以看到线程池的线程空闲时间为0，缓存队列为DelayedWorkQueue

实际使用：

线程池中1个线程的执行结果：

线程池中2个线程的执行结果：

如在单线程情况下，每个任务耗费1秒，6个任务耗费6秒，则超过了下一次线程调度的5秒周期
单线程执行结果：

如在多线程情况下，每个任务耗费3秒,2个线程下，增加一个任务，7个任务，超过了下一次线程调度的5秒周期，则下一次调度时间为实际任务结束的时间，

如在多个线程下：eg：2个线程下，3秒即可完成6个任务，而3秒小于任务调度周期时间5秒，因此下次按照设置的5秒频率执行
执行结果：

情况一：任务所需执行时间为1秒的时候 ，实际下一次执行时间为1秒 + 默认delay 5秒=6秒

执行结果：

情况二：任务所需执行时间为6秒超过默认delay=5秒的时候 ，实际下一次执行时间为6秒 + 默认delay 5秒=11秒
将上面的run方法中的睡眠时间改成6秒 TimeUnit.SECONDS.sleep(6); 以后
执行结果：

可以发现，scheduleWithFixedDelay方法 任务执行时间1秒小于或者6秒大于默认的delay延迟，下次执行时间均为上次任务完成时间+delay

java线程池之newScheduledThreadPool

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 static void main(String[] args) {
        /**             周期性线程池
         *                      ThreadPoolExecutor(corePoolSize,
         *                                      Integer.MAX_VALUE,
         *                                      0,
         *                                      NANOSECONDS,
         *                                      new DelayedWorkQueue(),
         *                                      Executors.defaultThreadFactory(),
         *                                      defaultHandler)
         *
         *  核心线程数，由用户自己指定，最大线程数为整数最大值
         *  超出核心线程数的线程空闲时间最大保持0纳秒（即空闲立刻销毁）
         *  默认工厂，默认拒绝策略
         */
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        for (int i=0; i<2; i++){
            System.out.println((new Date()).toLocaleString());
            ThreadPool threadPool = new ThreadPool(""+i);
            /**
             *  schedule(Runnable command,long delay,TimeUnit unit)
             *  command:执行的任务，Runnable或Callable接口的实现类
             *  delay:延迟执行时间，即启动后，多长时间后执行
             *  unit：延迟时间的单位
             */
            //scheduledExecutorService.schedule(threadPool,2, TimeUnit.SECONDS);

            /**
             * scheduleAtFixedRate(Runnable command,long initialDelay,long period,TimeUnit unit);
             *  command:执行的任务，Runnable的接口的的实现类的实例（该方法没有重载方法，所以只能是Runnable的继承类的实例）
             *  initialDelay:延迟执行时间，即启动后，多长时间后执行
             *  period:连续执行任务的周期，本次代码中，起了十个任务，这十个任务会重复执行。
             *          period代表十个任务执行中第一个任务开始执行到  下一组的十个任务的第一个任务开始执行的时间段
             *          此处要特别注意：若第一个十组任务执行未完成，但执行周期已经过了，第二个十组任务不会开始执行，
             *                          直到第一个十组任务执行完成，第二组才会开始执行
             *  unit:延迟时间的单位
             */
            //scheduledExecutorService.scheduleAtFixedRate(threadPool,2,5,TimeUnit.SECONDS);

            /**
             * scheduleWithFixedDelay与scheduleAtFixedRate的区别是：
             *  此方法的间隔时间是按照第一组任务执行结束才开始计算间隔时间的
             */
            scheduledExecutorService.scheduleWithFixedDelay(threadPool,2,5,TimeUnit.SECONDS);
        }
        //测试时，一定要注释shutdown()方法或者主线程睡一觉，否则不会打印，就会关闭线程池
       // scheduledExecutorService.shutdown();
    }
}

线程任务测试类

package com.thread.pool;

import java.util.Date;

public class ThreadPool implements Runnable {

    private static ThreadPool threadPool = null;
    String name;

    public ThreadPool(String name){
        this.name = name;
    }
    @Override
    public void run() {
        doSomeThing();
    }

    public static synchronized Runnable getInstance(){
        if(threadPool == null){
            threadPool = new ThreadPool("getInstance");
        }
        return getInstance();
    }

    private void doSomeThing() {

        for (int i=0;i<10;i++){
            System.out.println((new Date()).toLocaleString() + "   " + Thread.currentThread().getName() + "执行" +i + ",name=" + name);
        }

       try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}