8

有没有办法确定 ScheduledExecutorService 下次何时触发的当前毫秒或其他时间度量？

scheduleTaskExecutorUpdate = Executors.newSingleThreadScheduledExecutor();

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

4

1 回答 1

9

如果您跟踪ScheduledFuture执行程序安排的所有任务的 s，那么可以。这变成了确定下一个任务必须触发之前的最小延迟的问题，这应该是一个相当可靠的估计。

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. 但是，您不能只将ScheduledFutures 放入队列中而不维护周期性任务引起的更改。幸运的是，这个类应该通过它的方法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);
于 2012-08-31T21:14:00.863 回答