三、ScheduledThreadPoolExecutor 支持周期调度执行线程池解析

三、ScheduledThreadPoolExecutor 支持周期调度执行线程池解析

• new ScheduledThreadPoolExecutor(xx,xx).scheduleWithFixedDelay(xx,xx,xx);

1、依赖关系

• ScheduledThreadPoolExecutor

  • extends ThreadPoolExecutor

  • implements ScheduledExecutorService

2、ScheduledExecutorService 方法介绍

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

• 描述

  • 按一定周期频率执行任务，任务开始period时间后，再开始下次执行

• 参数

  • command ：具体任务

  • initialDelay ： 初始化后的延迟时间

  • period ：任务间隔时间

  • unit ：时间单位

2.2、 scheduleWithFixedDelay(Runnable command,long initialDelay,long delay,TimeUnit unit);

• 描述

  • 按一定延迟执行任务，任务结束delay时间后，再开始下次执行

• 参数

  • command ：具体任务

  • initialDelay ： 初始化后的延迟时间

  • delay ：任务延迟时间

  • unit ：时间单位

2.3、 schedule(Runnable command,long delay, TimeUnit unit);

• 描述

  • 在延迟delay后执行任务，不重复执行

3、运行流程

• a）创建ScheduledFutureTask包装task

• b) 往任务队列里添加task，任务队列使用DelayedWorkQueue延迟队列

• c）创建线程worker，从任务队列中获取任务执行

• d) ScheduledFutureTask执行时，如果是周期任务，则在执行完后，设置下次执行时间，并将任务重新放到队列中

• e) DelayedWorkQueue延迟队列会按照执行时间对任务排序，先执行的放在前面

4、解析

    public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
    }

• 从线程池构造中可以看出，可普通的线程池不一样的地方就是使用了DelayedWorkQueue

4.1、 以scheduleWithFixedDelay为例分析

        public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit) {
            if (command == null || unit == null)
                throw new NullPointerException();
            if (delay <= 0)
                throw new IllegalArgumentException();

            //构造ScheduledFutureTask,time的相对时间会转成绝对时间
            ScheduledFutureTask<Void> sft =
                new ScheduledFutureTask<Void>(command,
                                              null,
                                              triggerTime(initialDelay, unit),
                                              unit.toNanos(-delay));
            RunnableScheduledFuture<Void> t = decorateTask(command, sft);
            sft.outerTask = t;
            //执行主入口
            delayedExecute(t);
            return t;
        }



        private void delayedExecute(RunnableScheduledFuture<?> task) {
            //如果线程池关闭，则调用拒绝策略
            if (isShutdown())
                reject(task);
            else {
                //往任务队列添加任务
                super.getQueue().add(task);
                if (isShutdown() &&
                    !canRunInCurrentRunState(task.isPeriodic()) &&
                    remove(task))
                    task.cancel(false);
                else
                    ensurePrestart();
            }
        }


        void ensurePrestart() {
            int wc = workerCountOf(ctl.get());
            //增加worker
            if (wc < corePoolSize)
                addWorker(null, true);
            else if (wc == 0)
                addWorker(null, false);
        }

• 可以看到，这里又回到了普通线程池的addWorker里，所以核心是在ScheduledFutureTask 以及 DelayedWorkQueue里

4.2 ScheduledFutureTask

• 构造函数

      ScheduledFutureTask(Runnable r, V result, long ns, long period) {
          super(r, result);
          this.time = ns;
          this.period = period;
          this.sequenceNumber = sequencer.getAndIncrement();
      }
  

• run方法

      public void run() {
          //判断是否要周期性执行，period=0 表示只执行一次
          boolean periodic = isPeriodic();
          //当前任务是否取消
          if (!canRunInCurrentRunState(periodic))
              cancel(false);
          //非周期，执行一次
          else if (!periodic)
              ScheduledFutureTask.super.run();
          //执行任务
          else if (ScheduledFutureTask.super.runAndReset()) {
              //设置下次执行时间
              setNextRunTime();
              //将当前任务重新加入任务队列
              reExecutePeriodic(outerTask);
          }
      }
  
      //设置下次执行等待时间
      private void setNextRunTime() {
          long p = period;
          //按开始时间周期运行
          if (p > 0)
              time += p;
          //按结束时间周期运行，依赖当前时间
          else
              time = triggerTime(-p);
      }
  
  
      void reExecutePeriodic(RunnableScheduledFuture<?> task) {
          if (canRunInCurrentRunState(true)) {
              //将当前任务重新加入任务队列
              super.getQueue().add(task);
              if (!canRunInCurrentRunState(true) && remove(task))
                  task.cancel(false);
              else
                  ensurePrestart();
          }
      }
  

4.3 DelayedWorkQueue

• 流程描述

  • 添加元素时，会按照等待时间time排序，time小的排在前面，便于取得时候先取

  • 取元素时，先取队首元素，为空则阻塞。如果元素有延迟时间delay(time - currrentTime)，则阻塞dalay

• 添加元素

  //添加元素，并且按照等待时间排序，等待时间短的排在前面
  public boolean offer(Runnable x) {
      if (x == null)
          throw new NullPointerException();
      RunnableScheduledFuture<?> e = (RunnableScheduledFuture<?>)x;
      final ReentrantLock lock = this.lock;
      lock.lock();
      try {
          int i = size;
          if (i >= queue.length)
              grow();
          size = i + 1;
          if (i == 0) {
              queue[0] = e;
              setIndex(e, 0);
          } else {
              siftUp(i, e);
          }
          if (queue[0] == e) {
              leader = null;
              available.signal();
          }
      } finally {
          lock.unlock();
      }
      return true;
  }
  
  //按照等待执行时间time排序，利用二叉堆算法进行排序
  private void siftUp(int k, RunnableScheduledFuture<?> key) {
      while (k > 0) {
          int parent = (k - 1) >>> 1;
          RunnableScheduledFuture<?> e = queue[parent];
          if (key.compareTo(e) >= 0)
              break;
          queue[k] = e;
          setIndex(e, k);
          k = parent;
      }
      queue[k] = key;
      setIndex(key, k);
  }
  
  ScheduledFutureTask
  //比较等待执行的时间，等待执行时间越小值越小
  public int compareTo(Delayed other) {
      if (other == this) // compare zero if same object
          return 0;
      if (other instanceof ScheduledFutureTask) {
          ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
          long diff = time - x.time;
          if (diff < 0)
              return -1;
          else if (diff > 0)
              return 1;
          else if (sequenceNumber < x.sequenceNumber)
              return -1;
          else
              return 1;
      }
      long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);
      return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
  }
  

• 获取元素

  //去队首元素，如果队列为空则阻塞
  //如果有延迟时间delay，则阻塞delay的时间
  public RunnableScheduledFuture<?> take() throws InterruptedException {
      final ReentrantLock lock = this.lock;
      lock.lockInterruptibly();
      try {
          for (;;) {
              //取队首元素
              RunnableScheduledFuture<?> first = queue[0];
              //如果队列为空，则阻塞
              if (first == null)
                  available.await();
              else {
                  //获取延迟时间
                  long delay = first.getDelay(NANOSECONDS);
                  //到时则返回
                  if (delay <= 0)
                      return finishPoll(first);
                  first = null; // don't retain ref while waiting
                  if (leader != null)
                      available.await();
                  else {
                      Thread thisThread = Thread.currentThread();
                      leader = thisThread;
                      try {
                          //阻塞delay的时间
                          available.awaitNanos(delay);
                      } finally {
                          if (leader == thisThread)
                              leader = null;
                      }
                  }
              }
          }
      } finally {
          if (leader == null && queue[0] != null)
              available.signal();
          lock.unlock();
      }
  }
  
  ScheduledFutureTask
  public long getDelay(TimeUnit unit) {
      return unit.convert(time - now(), NANOSECONDS);
  }