《Java并发库系列三》一newSingleThreadScheduledExecutor

newSingleThreadScheduledExecutor：产生一个ScheduledExecutorService对象，这个对象的线程池大小为1，如果任务多于一个，任务将按先后顺序执行。

1、继承结构

构造函数

包含一个定时的service

      public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
      return new DelegatedScheduledExecutorService
       (new ScheduledThreadPoolExecutor(1));
      }
      static class DelegatedScheduledExecutorService
      extends DelegatedExecutorService
      implements ScheduledExecutorService {
      private final ScheduledExecutorService e;
       DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
      super(executor);
       e = executor;
       }
  
 

2、怎么保证只有一个线程

定时执行的时候调用这个方法，调用过程如下，注意看其中的注释，由上往下的调用顺序

      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<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();
       }
      }
      // 如果worker数量小于corePoolSize,创建新的线程，其他情况不处理
      void ensurePrestart() {
      int wc = workerCountOf(ctl.get());
      if (wc < corePoolSize)
       addWorker(null, true);
      else if (wc == 0)
       addWorker(null, false);
      }
  
 

3、怎么保证时间可以定时执行

      public ScheduledFuture<?> schedule(Runnable command,
      long delay,
       TimeUnit unit) {
      if (command == null || unit == null)
      throw new NullPointerException();
       RunnableScheduledFuture<?> t = decorateTask(command,
      new ScheduledFutureTask<Void>(command, null,
       triggerTime(delay, unit)));
       delayedExecute(t);
      return t;
      }
  
 

 在每次执行的时候会把下一次执行的时间放进任务中

      private long triggerTime(long delay, TimeUnit unit) {
      return triggerTime(unit.toNanos((delay < 0) ? 0 : delay));
      }
      /**
       * Returns the trigger time of a delayed action.
       */
      long triggerTime(long delay) {
      return now() +
       ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
      }
  
 

 FutureTask 定时是通过LockSupport.parkNanos(this, nanos);LockSupport.park(this);

      private int awaitDone(boolean timed, long nanos)
      throws InterruptedException {
      final long deadline = timed ? System.nanoTime() + nanos : 0L;
       WaitNode q = null;
      boolean queued = false;
      for (;;) {
      if (Thread.interrupted()) {
       removeWaiter(q);
      throw new InterruptedException();
       }
      int s = state;
      if (s > COMPLETING) {
      if (q != null)
       q.thread = null;
      return s;
       }
      else if (s == COMPLETING) // cannot time out yet
       Thread.yield();
      else if (q == null)
       q = new WaitNode();
      else if (!queued)
       queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
       q.next = waiters, q);
      else if (timed) {
       nanos = deadline - System.nanoTime();
      if (nanos <= 0L) {
       removeWaiter(q);
      return state;
       }
      //注意这里
       LockSupport.parkNanos(this, nanos);
       }
      else //注意这里
       LockSupport.park(this);
       }
      }
  
 

总结：Executor是通过将任务放在队列中，生成的futureTask。然后将生成的任务在队列中排序，将时间最近的需要出发的任务做检查。如果时间不到，就阻塞线程到下次出发时间。

注意：newSingleThreadScheduledExecutor只会有一个线程，不管你提交多少任务，这些任务会顺序执行，如果发生异常会取消下面的任务，线程池也不会关闭，注意捕捉异常

4、使用

      ScheduledExecutorService single = Executors.newSingleThreadScheduledExecutor();
      Runnable runnable1 = () -> {
      try {
       Thread.sleep(4000);
       System.out.println("11111111111111");
       } catch (InterruptedException e) {
       e.printStackTrace();
       }
      };
      Runnable runnable2 = () -> {
      try {
       Thread.sleep(4000);
       System.out.println("222");
       } catch (InterruptedException e) {
       e.printStackTrace();
       }
      };
      single.scheduleWithFixedDelay(runnable1,0,1, TimeUnit.SECONDS);
      single.scheduleWithFixedDelay(runnable2,0,2, TimeUnit.SECONDS);
  
 

      11111111111111
      222
      11111111111111
      222
      11111111111111
  
 

 在项目中要注意关闭线程池

      actionService = Executors.newSingleThreadScheduledExecutor();
       actionService.scheduleWithFixedDelay(() -> {
      try {
       Thread.currentThread().setName("robotActionService");
       Integer robotId = robotQueue.poll();
      if (robotId == null) {
      // 关闭线程池
       actionService.shutdown();
       } else {
      int aiLv = robots.get(robotId);
      if (actionQueueMap.containsKey(aiLv)) {
       ActionQueue actionQueue = actionQueueMap.get(aiLv);
       actionQueue.doAction(robotId);
       }
       }
       } catch (Exception e) {
      // 捕捉异常
       LOG.error("",e);
       }
       }, 1, 1, TimeUnit.SECONDS);
  
 

欢迎转载，我是香菜，谢谢。欢迎加入QQ群：632603498，一起学习

文章来源: gamwatcher.blog.csdn.net，作者：香菜聊游戏，版权归原作者所有，如需转载，请联系作者。

原文链接：gamwatcher.blog.csdn.net/article/details/88536377