@Override public ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) { return delegate.schedule(command, delay, unit); }
@Override public ListenableScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) { return delegate.scheduleAtFixedRate(command, initialDelay, period, unit); }
@Override public ListenableFuture<?> submit(Runnable task) { return delegate.submit(task); }
public void testNoOpScheduledExecutorShutdown() { ListeningScheduledExecutorService executor = TestingExecutors.noOpScheduledExecutor(); assertFalse(executor.isShutdown()); assertFalse(executor.isTerminated()); executor.shutdown(); assertTrue(executor.isShutdown()); assertTrue(executor.isTerminated()); }
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<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) { return delegate.scheduleWithFixedDelay(command, initialDelay, delay, unit); } }
public void testListeningDecorator_schedulePeriodic() throws Exception { ScheduledThreadPoolExecutor delegate = new ScheduledThreadPoolExecutor(1); ListeningScheduledExecutorService service = listeningDecorator(delegate); RuntimeException ex = new RuntimeException(); ListenableFuture<?> future; ThrowingRunnable runnable = new ThrowingRunnable(5, ex); future = service.scheduleAtFixedRate(runnable, 1, 1, TimeUnit.MILLISECONDS); assertExecutionException(future, ex); assertEquals(5, runnable.count); assertEquals(0, delegate.getQueue().size()); runnable = new ThrowingRunnable(5, ex); future = service.scheduleWithFixedDelay(runnable, 1, 1, TimeUnit.MILLISECONDS); assertExecutionException(future, ex); assertEquals(5, runnable.count); assertEquals(0, delegate.getQueue().size()); }
@Override public void shutdown() { delegate.shutdown(); }
@Override public List<Runnable> shutdownNow() { return delegate.shutdownNow(); }
this.executorService.shutdown(); while (!this.executorService.isTerminated() && wait-- > 0) { try { this.executorService.awaitTermination(100, TimeUnit.MILLISECONDS); } catch (InterruptedException e) { List<Runnable> remainRunning = this.executorService.shutdownNow(); for (Runnable runnable : remainRunning) { LOGGER.warn("Runnable " + runnable.getClass().getName() + " has been terminated due to shutdown");
!executorService.awaitTermination( lookupCoordinatorManagerConfig.getHostTimeout().getMillis() * 10, TimeUnit.MILLISECONDS this.backgroundManagerFuture = executorService.scheduleWithFixedDelay( this::lookupManagementLoop, lookupCoordinatorManagerConfig.getInitialDelay(),
@Override public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { return delegate.awaitTermination(timeout, unit); }
void shutdownExecutor() { LOGGER.trace("Shutting down executor.."); final ListeningScheduledExecutorService ex = realtimeState.executor; if (ex != null) { ex.shutdown(); // in case the future could not be cancelled before, do it now final ListenableScheduledFuture<?> fut = realtimeState.schedulerFuture; if (fut != null && !fut.isDone()) { realtimeState.cancelTask(); } try { ex.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS); } catch (final InterruptedException e) { throw new IllegalStateException(e); } LOGGER.trace("Executor shutdown."); } verifyNotNull(affinityLock).release(); }
@Override public ListenableScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) { return delegate.scheduleWithFixedDelay(command, initialDelay, delay, unit); }
@Override protected void shutDown() throws Exception { logger.info( "Shutting down job scheduler" ); service.shutdown(); logger.info( "Job scheduler shut down" ); super.shutDown(); }
public void testNoOpScheduledExecutorShutdown() { ListeningScheduledExecutorService executor = TestingExecutors.noOpScheduledExecutor(); assertFalse(executor.isShutdown()); assertFalse(executor.isTerminated()); executor.shutdown(); assertTrue(executor.isShutdown()); assertTrue(executor.isTerminated()); }
@LifecycleStop public void stop() { synchronized (lock) { if (!started) { return; } started = false; future.cancel(true); future = null; derivativesRef.set(new ConcurrentHashMap<>()); exec.shutdownNow(); exec = null; } }
/** Can just use stop() here instead of stopAsync/awaitTerminated: PeerGroup is no longer a Guava service. */ @Deprecated public void awaitTerminated() { try { executor.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS); } catch (InterruptedException e) { throw new RuntimeException(e); } }
@Override public <V> ListenableScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) { return delegate.schedule(callable, delay, unit); }