java - 确定什么时候下一次ScheduledExecutorService会触发

有没有一种方法可以确定下一个ScheduledExecutorService将在何时触发的当前毫秒或其他时间度量？

scheduleTaskExecutorUpdate = Executors.newSingleThreadScheduledExecutor();

我有一个运行时间更长的ScheduledExecutorService(A)，而从运行时间较短的ScheduledExecutorService(B)中，我想更新一个TextView，显示下一个ScheduledExecutorService(A)何时触发的倒计时。

最佳答案

如果跟踪执行器安排的所有任务的 ScheduledFuture ，则可以。这成为确定下一个任务必须执行之前的最小延迟的问题，这应该是一个相当可靠的估计。

final Collection<ScheduledFuture<?>> futures = ...;
/* for each schedule, add it to the above collection */
...
final long delay = Collections.min(futures).getDelay(TimeUnit.MILLISECONDS);

...或者，对于一项任务，您只需要执行以下操作:

final ScheduledFuture<?> future = ...;
final long delay = future.getDelay(TimeUnit.MILLISECONDS);

现在，如果您要执行很多任务，需要执行多个任务，建议您维护一个 DelayQueue 。但是，您不能仅将ScheduledFuture扔到队列中，而不能维持由定期任务引起的更改。幸运的是，类 ScheduledThreadPoolExecutor 应该通过其 decorateTask 方法很好地处理此问题。

请注意，这意味着您将需要直接创建自己的ScheduledThreadPoolExecutor。类似以下内容可能会起作用。

public class TrackingSingleThreadScheduledExecutor
    extends ScheduledThreadPoolExecutor {

  private final DelayQueue<ScheduledFuture<?>> tasks
      = new DelayQueue<RunnableScheduledFuture<?>>();

  public TrackingSingleThreadScheduledExecutor() {
    super(1);
  }

  public DelayQueue<? extends ScheduledFuture<V>> tasks() {
    return tasks;
  }

  public ScheduledFuture<V> next() {
    return tasks.peek();
  }

  protected <V> RunnableScheduledFuture<V> decorateTask
      (final Callable<V> callable, final RunnableScheduledFuture<V> task) {
    return new QueueAwareTask(task);
  }

  protected <V> RunnableScheduledFuture<V> decorateTask
      (final Runnable runnable, final RunnableScheduledFuture<V> task) {
    return new QueueAwareTask(task);
  }

  private final class QueueAwareTask<V> implements RunnableScheduledFuture<V> {

    private final RunnableScheduledFuture<V> inner;

    public QueueAwareTask(final RunnableScheduledFuture<V> inner) {
      this.inner = inner;
    }

    public boolean isPeriodic() {
      return inner.isPeriodic();
    }

    public long getDelay(final TimeUnit unit) {
      return inner.getDelay(unit);
    }

    public void run() {
      inner.run();
      if (queue.remove(inner) && inner.isPeriodic()
          && !inner.isCancelled()) {
        queue.add(inner);
      }
    }

    public int compareTo(final Delayed other) {
      return inner.compareTo(other);
    }

    public boolean cancel(final boolean mayInterruptIfRunning) {
      final boolean cancelled = inner.cancel(mayInterruptIfRunning);
      if (cancelled) {
        queue.remove(inner);
      }
      return cancelled;
    }

    public boolean isCancelled() {
      return inner.isCancelled();
    }

    public boolean isDone() {
      return inner.isDone();
    }

    public V get() throws InterruptedException, ExecutionException {
      return inner.get();
    }

    public V get(final long timeout, final TimeUnit unit)
        throws InterruptedException, ExecutionException {
      return inner.get(timeout, unit);
    }
  }
}

然后，用法如下。

final TrackingSingleThreadScheduledExecutor executor
    = new TrackingSingleThreadScheduledExecutor();
...
final long delay = executor.next().getDelay(TimeUnit.MILLISECONDS);