static void tryStart(boolean purgeEnabled) { if (purgeEnabled) { for (;;) { ScheduledExecutorService curr = PURGE_THREAD.get(); if (curr != null) { return; } ScheduledExecutorService next = Executors.newScheduledThreadPool(1, new RxThreadFactory("RxSchedulerPurge")); if (PURGE_THREAD.compareAndSet(curr, next)) { next.scheduleAtFixedRate(new ScheduledTask(), PURGE_PERIOD_SECONDS, PURGE_PERIOD_SECONDS, TimeUnit.SECONDS); return; } else { next.shutdownNow(); } } } }
public void reschedule(long timeOut, TimeUnit timeUnit) { ScheduledFuture<?> future = reference.getAndSet(null); if (future != null) { if (future.cancel(false)) { future = service.schedule(task, timeOut == 0 ? Integer.MAX_VALUE : timeOut, timeOut == 0 ? TimeUnit.SECONDS : timeUnit); reference.set(future); } } else { future = service.schedule(task, timeOut == 0 ? Integer.MAX_VALUE : timeOut, timeOut == 0 ? TimeUnit.SECONDS : timeUnit); reference.set(future); } } }
/** * For testing: force this web socket to release its threads. */ void tearDown() throws InterruptedException { if (cancelFuture != null) { cancelFuture.cancel(false); } executor.shutdown(); executor.awaitTermination(10, TimeUnit.SECONDS); }
void stop() { executor.shutdown(); try { if (!executor.awaitTermination(1, TimeUnit.SECONDS)) { executor.shutdownNow(); } } catch (InterruptedException ignored) { executor.shutdownNow(); } }
configuration.getClass(StressTestUtils.STRESSOR_CLASS, StressTestUtils.DEFAULT_STRESSOR_CLASS, Stressor.class); ExecutorService executorService = Executors.newFixedThreadPool(stressorThreads); ThrottlingPolicy policy = (ThrottlingPolicy) broker.getSharedResource(new ThrottlingPolicyFactory(), new SharedLimiterKey(resourceLimited)); ScheduledExecutorService reportingThread = Executors.newSingleThreadScheduledExecutor(); reportingThread.scheduleAtFixedRate(new Reporter(limiterContainer, policy), 0, 15, TimeUnit.SECONDS); futures.add(executorService.submit(new StressorRunner(limiterContainer.decorateLimiter(restliLimiter), stressor))); for (Future<?> future : futures) { try { future.get(); } catch (ExecutionException ee) { stressorFailures++; executorService.shutdownNow();
ExecutorService service1 = Executors.newSingleThreadExecutor(); ScheduledExecutorService service2 = null; try { Future f = service1.submit(() -> { final ExcerptAppender appender = queue.acquireAppender(); service2 = Executors.newSingleThreadScheduledExecutor(); service2.scheduleAtFixedRate(() -> { Bytes b = Bytes.elasticHeapByteBuffer(128); final ExcerptTailer tailer = queue.createTailer(); if (bytes == null) { f.get(1, TimeUnit.SECONDS); throw new NullPointerException("nothing in result"); f.get(1, TimeUnit.SECONDS); } finally { bytes.release(); service1.shutdownNow(); if (service2 != null) service2.shutdownNow();
final AtomicReference<Integer> replicasRef = new AtomicReference<>(0); ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); ScheduledFuture poller = executor.scheduleWithFixedDelay(tPoller, 0, POLL_INTERVAL_MS, TimeUnit.MILLISECONDS); try { if (Utils.waitUntilReady(queue, rollingTimeout, rollingTimeUnit)) { Log.debug("{}/{} pod(s) ready for {}: {} in namespace: {}.", replicasRef.get(), count, getType().getSimpleName(), name, namespace); } else { Log.error("{}/{} pod(s) ready for {}: {} in namespace: {} after waiting for {} seconds so giving up", replicasRef.get(), count, getType().getSimpleName(), name, namespace, rollingTimeUnit.toSeconds(rollingTimeout)); poller.cancel(true); executor.shutdown();
@Test public void scanSupportBuffered() throws InterruptedException { Executor plain = Runnable::run; ExecutorService plainService = Executors.newSingleThreadExecutor(); ExecutorService threadPool = Executors.newFixedThreadPool(3); ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4); .as("plainService").isEqualTo(null); scheduledThreadPool.schedule(() -> {}, 500, TimeUnit.MILLISECONDS); scheduledThreadPool.schedule(() -> {}, 500, TimeUnit.MILLISECONDS); Thread.sleep(50); //give some leeway for the pool to have consistent accounting .as("scheduledThreadPool").isEqualTo(2); threadPool.submit(() -> { try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } }); plainService.shutdownNow(); unsupportedScheduledExecutorService.shutdownNow(); threadPool.shutdownNow(); scheduledThreadPool.shutdownNow();
/** * For JMX to forget about all previously exported metrics. */ public static void clearJmxCache() { if (LOG.isTraceEnabled()) { LOG.trace("clearing JMX Cache" + StringUtils.stringifyException(new Exception())); } //If there are more then 100 ms before the executor will run then everything should be merged. ScheduledFuture future = fut.get(); if ((future != null && (!future.isDone() && future.getDelay(TimeUnit.MILLISECONDS) > 100))) { // BAIL OUT return; } if (stopped.get()) { return; } future = executor.getExecutor().schedule(new JmxCacheBusterRunnable(), 5, TimeUnit.SECONDS); fut.set(future); }
assertFalse(p.submit(r).isDone()); if (stock) assertTrue(!((FutureTask) recorder.r).isDone()); assertSame(p, recorder.p); future = s.schedule(r, randomTimeout(), randomTimeUnit()); assertFalse(future.isDone()); if (stock) assertTrue(!((FutureTask) recorder.r).isDone()); assertSame(p, recorder.p); future = s.schedule(c, randomTimeout(), randomTimeUnit()); assertFalse(future.isDone()); if (stock) assertTrue(!((FutureTask) recorder.r).isDone()); assertSame(p, recorder.p); future = s.scheduleAtFixedRate(r, randomTimeout(), LONG_DELAY_MS, MILLISECONDS); assertFalse(future.isDone()); if (stock) assertTrue(!((FutureTask) recorder.r).isDone()); assertSame(p, recorder.p); future = s.scheduleWithFixedDelay(r, randomTimeout(), LONG_DELAY_MS, MILLISECONDS); assertFalse(future.isDone()); if (stock) assertTrue(!((FutureTask) recorder.r).isDone()); final AtomicReference<Thread> thread = new AtomicReference<>(); final Runnable setThread = () -> thread.set(Thread.currentThread());
int expectedUnknown = Integer.MIN_VALUE; ExecutorService executorService1 = Executors.newSingleThreadExecutor(); ScheduledExecutorService executorService2 = Executors.newSingleThreadScheduledExecutor(); ExecutorService executorService3 = Executors.newCachedThreadPool(); ExecutorService executorService4 = Executors.newFixedThreadPool(2); ScheduledExecutorService executorService5 = Executors.newScheduledThreadPool(3); int maxSub8 = WorkQueueProcessor.bestEffortMaxSubscribers(executorService8); executorService1.shutdown(); executorService2.shutdown(); executorService3.shutdown(); executorService4.shutdown(); executorService5.shutdown(); executorService6.shutdown(); executorService7.shutdown();
final AtomicBoolean done = new AtomicBoolean(); ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor(); ScheduledFuture<?> timer = executorService.schedule(new Runnable() { @Override public void run() { } finally { synchronized (monitor) { done.set(true); timer.cancel(true); executorService.shutdownNow();
ExecutorService service = Executors.newFixedThreadPool(N); ScheduledExecutorService canceller = Executors.newSingleThreadScheduledExecutor(); public <T> Future<T> executeTask(Callable<T> c, long timeoutMS){ final Future<T> future = service.submit(c); canceller.schedule(new Callable<Void>(){ public Void call(){ future.cancel(true); return null; } }, timeoutMS, TimeUnit.MILLI_SECONDS); return future; }
public void stop() { try { if (start.compareAndSet(true, false)) { scheduledFuture.cancel(true); FIXED_EXECUTOR_SERVICE.shutdown(); } LOGGER.info("Executing dead job checker stopped!"); } catch (Throwable t) { LOGGER.error("Executing dead job checker stop failed!", t); } }
ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); final Future handler = executor.submit(new Callable(){ ... }); executor.schedule(new Runnable(){ public void run(){ handler.cancel(); } }, 10000, TimeUnit.MILLISECONDS);
@AfterMethod public void tearDown() { executor.shutdownNow(); scheduledExecutor.shutdownNow(); }
private void waitForObservedGeneration(final long observedGeneration) { final CountDownLatch countDownLatch = new CountDownLatch(1); final Runnable deploymentPoller = new Runnable() { public void run() { Deployment deployment = oper.getMandatory(); if (observedGeneration <= deployment.getStatus().getObservedGeneration()) { countDownLatch.countDown(); } } }; ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); ScheduledFuture poller = executor.scheduleWithFixedDelay(deploymentPoller, 0, 10, TimeUnit.MILLISECONDS); try { countDownLatch.await(1, TimeUnit.MINUTES); executor.shutdown(); } catch (InterruptedException e) { poller.cancel(true); executor.shutdown(); throw KubernetesClientException.launderThrowable(e); } }
@Test public void scanExecutorCapacity() { Executor plain = Runnable::run; ExecutorService plainService = Executors.newSingleThreadExecutor(); ExecutorService threadPool = Executors.newFixedThreadPool(3); ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4); DelegateServiceScheduler.UnsupportedScheduledExecutorService unsupportedScheduledExecutorService = new DelegateServiceScheduler.UnsupportedScheduledExecutorService(threadPool); try { assertThat(Schedulers.scanExecutor(plain, Scannable.Attr.CAPACITY)) .as("plain").isEqualTo(null); assertThat(Schedulers.scanExecutor(plainService, Scannable.Attr.CAPACITY)) .as("plainService").isEqualTo(null); assertThat(Schedulers.scanExecutor(threadPool, Scannable.Attr.CAPACITY)) .as("threadPool").isEqualTo(3); assertThat(Schedulers.scanExecutor(scheduledThreadPool, Scannable.Attr.CAPACITY)) .as("scheduledThreadPool").isEqualTo(Integer.MAX_VALUE); assertThat(Schedulers.scanExecutor(unsupportedScheduledExecutorService, Scannable.Attr.CAPACITY)) .as("unwrapped").isEqualTo(3); } finally { plainService.shutdownNow(); unsupportedScheduledExecutorService.shutdownNow(); threadPool.shutdownNow(); scheduledThreadPool.shutdownNow(); } }