05、定时任务线程池ScheduledThreadPoolExecutor的使用

1. ScheduledThreadPoolExecutor介绍

  • ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后执行任务,或者定期执行任务。通常使用工厂类Executors来创建。
  • ScheduledThreadPoolExecutor的功能与Timer类似,但比Timer更强大,更灵活,Timer对应的是单个后台线程,而ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。

2.ScheduledThreadPoolExecutor的两种类型

1、 ScheduledThreadPoolExecutor:执行并行任务也就是多条线程同时执行;
2、 SingleThreadScheduledExecutor:执行单条线程;

2.1. ScheduledThreadPoolExecutor

使用Executors创建ScheduledThreadPoolExecutor的方法构造如下:

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {

        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {

        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }
2.2. SingleThreadScheduledExecutor

使用Executors创建SingleThreadScheduledExecutor的方法构造如下:

public static ExecutorService newSingleThreadExecutor() {

        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {

        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }
2.3. 创建实例
ScheduledExecutorService scheduledThreadPoolExecutor=Executors.newScheduledThreadPool(5);

ScheduledExecutorService singleThreadScheduledExecutor=Executors.newSingleThreadScheduledExecutor();
2.4 使用场景
  • ScheduledThreadPoolExecutor:适用于多个后台线程执行周期性任务,同时为了满足资源管理的需求而需要限制后台线程数量的应用场景。
  • SingleThreadScheduledExecutor:适用于需要单个后台线程执行周期任务,同时需要保证任务顺序执行的应用场景。

3. ScheduledThreadPoolExecutor执行机制分析

&nbsp;
注意:DelayQueue是一个无界队列,所以ThreadPoolExecutor的maximumPoolSize在ScheduledThreadPoolExecutor中无意义。

ScheduledThreadPoolExecutor的执行主要分为以下两个部分:

  • 当调用ScheduledThreadPoolExecutor的scheduleAtFixedRate()方法或者scheduleWithFixedDelay()方法时,会向ScheduledThreadPoolExecutor的DelayQueue添加一个实现了RunnableScheduledFuture接口的ScheduleFutureTask。
  • 线程池中的线程从DelayQueue中获取ScheduleFutureTask,然后执行任务。

4. ScheduledThreadPoolExecutor使用案例

创建一个Runnable的对象,然后使用ScheduledThreadPoolExecutor的Scheduled()来执行延迟任务。

4.1 延迟指定时间才开始执行schedule。
public ScheduledFuture schedule(Runnable command,long delay, TimeUnit unit);

参数解析

  • command:实现Runnable接口的类
  • delay:延迟多久后执行
  • unit:用于指定keepAliveTime参数的时间单位,这是一个枚举,常用的有TimeUnit.MILLISECONDS(毫秒),TimeUnit.SECONDS(秒)以及TimeUnit.MINUTES(分钟)等
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @authorSaint
 * @version 1.0
 * @date 2020/8/9 15:05
 */
public class Main {

    public static void main(String[] args) {

        ScheduledExecutorService scheduledThreadPoolExecutor= Executors.newScheduledThreadPool(1);
        long cur = System.currentTimeMillis();
        System.out.println("延迟要开始了");
        scheduledThreadPoolExecutor.schedule(new Runnable() {

            @Override
            public void run() {

                System.out.println("Hello, World!");
            }
            //0表示首次执行任务的延迟时间,1000表示每次执行任务的间隔时间,TimeUnit.MILLISECONDS执行的时间间隔数值单位
        }, 2000, TimeUnit.MILLISECONDS);
        long stop = System.currentTimeMillis();
    }
}
4.2 周期性执行任务
  • scheduleAtFixedRate方法的作用是预定在初始的延迟结束后,周期性地执行给定的任务,周期长度为period,其中initialDelay为初始延迟。
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);
  • scheduleWithFixedDelay方法的作用是预定在初始的延迟结束后周期性地执行给定任务,在一次调用完成和下一次调用开始之间有长度为delay的延迟,其中initialDelay为初始延迟
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

案例代码

package cn.com.wind.windabc.shceduledthreadpool;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 定时任务,并增加执行次数限制
 * @author Saint
 * @version 1.0
 * @date 2020/8/9 15:14
 */
public class ScheduledMultiThreadTool {

    private  static Integer count =1;
    MyTimerTask myTimerTask = new MyTimerTask();
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(2);

    public void start(){

        try {

            //一秒执行一次
            scheduled.scheduleAtFixedRate(myTimerTask, 0,1, TimeUnit.SECONDS);
            while (!scheduled.isTerminated()){

                lock.readLock().lock();
                if (count >20){

                    scheduled.shutdown();
                }
                lock.readLock().unlock();

            }
        }catch(Exception e){

            e.printStackTrace();
        }
        System.out.println("Finished all threads");
    }
    private class MyTimerTask implements Runnable {

        @Override
        public void run(){

            lock.writeLock().lock();
            System.out.println("第 "+count+ " 次执行任务,count="+count);
            count ++;
            lock.writeLock().unlock();
        }

    }

    public static void main(String[] args) {

        new ScheduledMultiThreadTool().start();
    }
}

限制程序执行的次数:如果是单线程,那么可以直接定义一个静态变量count,每执行一次,count加一,如果count大于某个值就调用shutdown或者shutdownNow函数;如果是多线程,稍微要复杂一点,但是原理也是一样的。定义一个静态变量count,没执行一个也是count加一,只不过在执行加一操作之前需要加锁,执行完之后需要解锁

附:时间单位
毫秒:TimeUnit.MILLISECONDS
秒:TimeUnit.SECONDS
分钟:TimeUnit.MINUTES
小时:TimeUnit.HOURS
天:TimeUnit.DAYS

总结

SingleThreadScheduledExecutor与ScheduledThreadPoolExecutor使用方法类似。
了解完ScheduledThreadPoolExecutor的创建方法和内置的几个schedule()方法后,使用起来还是很简单的。
我们主要记住两个类:SingleThreadScheduledExecutor、ScheduledThreadPoolExecutor