@Override public <V> ListenableScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) { return delegate.schedule(callable, delay, unit); }
public void testListeningDecorator_cancelled() throws Exception { ScheduledThreadPoolExecutor delegate = new ScheduledThreadPoolExecutor(1); BlockingQueue<?> delegateQueue = delegate.getQueue(); ListeningScheduledExecutorService service = listeningDecorator(delegate); ListenableFuture<?> future; ScheduledFuture<?> delegateFuture; Runnable runnable = new Runnable() { @Override public void run() {} }; future = service.schedule(runnable, 5, TimeUnit.MINUTES); future.cancel(true); assertTrue(future.isCancelled()); delegateFuture = (ScheduledFuture<?>) delegateQueue.element(); assertTrue(delegateFuture.isCancelled()); delegateQueue.clear(); future = service.scheduleAtFixedRate(runnable, 5, 5, TimeUnit.MINUTES); future.cancel(true); assertTrue(future.isCancelled()); delegateFuture = (ScheduledFuture<?>) delegateQueue.element(); assertTrue(delegateFuture.isCancelled()); delegateQueue.clear(); future = service.scheduleWithFixedDelay(runnable, 5, 5, TimeUnit.MINUTES); future.cancel(true); assertTrue(future.isCancelled()); delegateFuture = (ScheduledFuture<?>) delegateQueue.element(); assertTrue(delegateFuture.isCancelled()); }
@Override public ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) { return delegate.schedule(command, delay, unit); }
private CompletableFuture<Collection<Slice>> scheduleAppend() { if (pageProcessingDelayMillis > 0) { return toCompletableFuture(executorService.schedule(() -> ImmutableList.of(), pageProcessingDelayMillis, MILLISECONDS)); } return NON_BLOCKED; }
@Override public ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) { return delegate.schedule(command, delay, unit); }
final ListenableScheduledFuture<?> cleanupTask = cleanupExec.schedule( new Runnable()
public void testListeningDecorator_scheduleFailure() throws Exception { ScheduledThreadPoolExecutor delegate = new ScheduledThreadPoolExecutor(1); ListeningScheduledExecutorService service = listeningDecorator(delegate); RuntimeException ex = new RuntimeException(); ListenableFuture<?> future = service.schedule(new ThrowingRunnable(0, ex), 1, TimeUnit.MILLISECONDS); assertExecutionException(future, ex); assertEquals(0, delegate.getQueue().size()); }
@Override public <V> ListenableScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) { this.schedulerCalls.add(new SchedulerCall(callable, delay, unit)); return delegate.schedule(callable, delay, unit); }
public void testNoOpScheduledExecutor() throws InterruptedException { taskDone = false; Runnable task = new Runnable() { @Override public void run() { taskDone = true; } }; ScheduledFuture<?> future = TestingExecutors.noOpScheduledExecutor().schedule(task, 10, TimeUnit.MILLISECONDS); Thread.sleep(20); assertFalse(taskDone); assertFalse(future.isDone()); }
@Override public <V> ListenableScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) { ListenableFutureTask<V> task = ListenableFutureTask.create(new MDCPropagatingCallable<>(callable)); ScheduledFuture<?> scheduled = executorService.schedule(task, delay, unit); return new ListenableScheduledTask<>(task, scheduled); }
@Override public ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) { ListenableFutureTask<Void> task = ListenableFutureTask.create(new MDCPropagatingRunnable(command), null); ScheduledFuture<?> scheduled = executorService.schedule(task, delay, unit); return new ListenableScheduledTask<>(task, scheduled); }
@SuppressWarnings("CheckReturnValue") private void handleFailure(final SettableFuture<Response> future, final Supplier<ListenableFuture<Response>> code, final long deadline, final long delayMillis, final Throwable th, final URI uri) { if (clock.now().getMillis() < deadline) { if (delayMillis > 0) { executorService.schedule(new Runnable() { @Override public void run() { startRetry(future, code, deadline - 1, delayMillis, uri); } }, delayMillis, TimeUnit.MILLISECONDS); } else { startRetry(future, code, deadline - 1, delayMillis, uri); } } else { future.setException(th); } }
@Override public Page getNextPage() { if (isFinished()) { return null; } if (currentPage != null) { Page page = getFutureValue(currentPage); currentPage = null; return page; } pagesLeft--; completedBytes += page.getSizeInBytes(); if (pageProcessingDelayInMillis == 0) { return page; } else { currentPage = toCompletableFuture(executorService.schedule(() -> page, pageProcessingDelayInMillis, MILLISECONDS)); return null; } }
public void testListeningDecorator_scheduleSuccess() throws Exception { final CountDownLatch completed = new CountDownLatch(1); ScheduledThreadPoolExecutor delegate = new ScheduledThreadPoolExecutor(1) { @Override protected void afterExecute(Runnable r, Throwable t) { completed.countDown(); } }; ListeningScheduledExecutorService service = listeningDecorator(delegate); ListenableFuture<Integer> future = service.schedule(Callables.returning(42), 1, TimeUnit.MILLISECONDS); /* * Wait not just until the Future's value is set (as in future.get()) but * also until ListeningScheduledExecutorService's wrapper task is done * executing listeners, as detected by yielding control to afterExecute. */ completed.await(); assertTrue(future.isDone()); assertThat(future.get()).isEqualTo(42); assertListenerRunImmediately(future); assertEquals(0, delegate.getQueue().size()); }
final ListenableScheduledFuture<?> cleanupTask = cleanupExec.schedule( new Runnable()
if (item == null) { if (!draining) { future = exec.schedule(() -> request(1), BACKOFF_DELAY_MS, TimeUnit.MILLISECONDS);
@SuppressWarnings({ "rawtypes", "unchecked" }) @Override public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) { return new ScheduledFuture(delegate().schedule(command, delay, unit)); }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Override public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) { return new ScheduledFuture(delegate().schedule(command, delay, unit)); }
private synchronized void processOnError() { if (this.closed) { return; } Util.addOnFailureLoggingCallback( this.connectionManager.getExecutorService(), this.scheduledExecutorService.schedule(() -> reset(), 500, TimeUnit.MILLISECONDS), LOG, "scheduled reset failed" ); }
@Override public <V> ListenableScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) { ListenableFutureTask<V> task = ListenableFutureTask.create(new MDCPropagatingCallable<>(callable)); ScheduledFuture<?> scheduled = executorService.schedule(task, delay, unit); return new ListenableScheduledTask<>(task, scheduled); }