class DirectExecutor implements Executor {
          public void execute(Runnable r) {
              r.run();
          }
    }

             // 记录所有已提交执行的任务,方便最后关闭
            List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);

            // 任务执行结果获取器,若提交的任务完成,则会被放入一个队列中.
            ExecutorCompletionService<T> ecs =
                new ExecutorCompletionService<T>(this);

            // 为了更有效率,尤其是在有并发限制的executor执行器上.在提交更多任务前,检查前一个提交的任务是否完成.
            // This interleaving plus the exception mechanics account for messiness of main loop. (异常叠加造成主循环混乱?)

            try {
                // 如果没有获取到任何结果,则抛出最后一个异常
                ExecutionException ee = null;

                // 记录上一个任务执行结束的时间点
                long lastTime = timed ? System.nanoTime() : 0;

                Iterator<? extends Callable<T>> it = tasks.iterator();

                // 将第一个任务提交并保存.
                futures.add(ecs.submit(it.next()));
                --ntasks;
                int active = 1;// 记录正在执行的任务个数

                for (;;) {
                    // 获取前面已提交任务的执行结果,若无结果 poll() 方法会立即返回null
                    Future<T> f = ecs.poll();
                    if (f == null) {
                       // 若前面的提交的任务都无执行结果
                        if (ntasks > 0) {
                           // 若还有未提交的任务,则提交一个任务.
                            --ntasks;
                            futures.add(ecs.submit(it.next()));
                            ++active;
                        }
                        else if (active == 0) // 若已经没有正在执行的任务.则跳出循环.
                            break;
                        else if (timed) {
                           // 若有超时限制, 则在时限内去获取最快完成任务的结果
                            f = ecs.poll(nanos, TimeUnit.NANOSECONDS);

                            //若无结果,则任务执行超时
                            if (f == null)
                                throw new TimeoutException();

                            // 记录最新完成的任务的时间点,并从时限中减去任务完成花费的时间
                            long now = System.nanoTime();
                            nanos -= now - lastTime;
                            lastTime = now;
                        }
                        else
                            f = ecs.take(); // 若无超时时限,则一直阻塞,直到有任务执行完成.
                    }
                    if (f != null) {
                      // 获取到结果,则有任务执行完成.执行中任务个数减一
                        --active;

                        // 获取任务执行结果失败, 则记录异常.所有任务都执行完成,仍无法获取结果时,抛出最后一个异常
                        try {
                            return f.get();
                        } catch (ExecutionException eex) {
                            ee = eex;
                        } catch (RuntimeException rex) {
                            ee = new ExecutionException(rex);
                        }
                    }
                }

                // 所有任务都执行完成,仍无法获取结果时,抛出最后一个异常
                if (ee == null)
                    ee = new ExecutionException();
                throw ee;

            } finally {
              // 方法返回前,关闭所有提交的任务(若有任务完成并成功返回结果.可能还有其他任务正在执行)
                for (Future<T> f : futures)
                    f.cancel(true);
            } -----

      while (it.hasNext()) {
            execute((Runnable)(it.next()));
            long now = System.nanoTime();
            nanos -= now - lastTime;
            lastTime = now;
            if (nanos <= 0)
                return futures;
        }

            public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

            public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);

            // 执行时间点为 initialDelay + execCount * period , exec 是执行次数
            public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);

            // 执行时间点为 initialDelay + period
            public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);

    public RunnableScheduledFuture take() throws InterruptedException {
               final ReentrantLock lock = this.lock;

               // 获取锁, 下面的`(Condition)available`调用的await()会释放锁.
               // 这个方法获取锁时,会校验线程是否已被中断, 若中断则抛出`InterruptedException`
               lock.lockInterruptibly();
               try {
                   for (;;) {
                       // 获取最小等待时间的待执行任务
                       RunnableScheduledFuture first = queue[0];

                       // 没有任务,则无限期等待,并释放锁.直到 DelayedWorkQueue.offer() 中调用 available.signal(),唤醒线程
                       if (first == null)
                           available.await();
                       else {
                           // 任务不为空,则获取任务执行还需要等待的时间
                           long delay = first.getDelay(TimeUnit.NANOSECONDS);

                           // 等待时间小于0, 则直接返回任务
                           if (delay <= 0)
                               return finishPoll(first);

                           // 等待时间大于0, 但是已有另一个线程,在等待任务可执行,则当前线程无限期等待
                           else if (leader != null)
                               available.await();
                           else {
                             // 若无其他线程等待该任务可调度,则将当前线程设置为等待该任务执行, 并等待任务延期执行时间.
                               Thread thisThread = Thread.currentThread();
                               leader = thisThread;
                               try {
                                   available.awaitNanos(delay);
                               } finally {
                                  // 如果唤醒的是leader线程,则需要将leader置null,
                                  // 不然别的线程后续被唤醒时,可能会进入上面if的无限期等待.  
                                   if (leader == thisThread)
                                       leader = null;
                               }
                           }
                       }
                   }
               } finally {
                 // 若下面的if条件满足,则表示其他所有获取任务的线程都处于无限期等待中,需要手动唤醒一个线程
                   if (leader == null && queue[0] != null)
                       available.signal();
                   lock.unlock();
               }
           }