Refine search
private synchronized void planNextTry(long afterMillis) { if (scheduledExecutorService == null) { scheduledExecutorService = Executors.newScheduledThreadPool(1); } scheduledExecutorService.schedule(this::tryPublish, afterMillis, TimeUnit.MILLISECONDS); }
cacheUpdateMaster = Executors.newScheduledThreadPool(1, new ThreadFactory() { @Override public Thread newThread(Runnable r) { cacheUpdateMaster.schedule(new CacheUpdateMasterWork(conf, shouldRunPrewarm), 0, TimeUnit.MILLISECONDS);
/** * Listing 7.2 Scheduling a task with a ScheduledExecutorService * */ public static void schedule() { ScheduledExecutorService executor = Executors.newScheduledThreadPool(10); ScheduledFuture<?> future = executor.schedule( new Runnable() { @Override public void run() { System.out.println("Now it is 60 seconds later"); } }, 60, TimeUnit.SECONDS); //... executor.shutdown(); }
import static java.util.concurrent.TimeUnit.*; class BeeperControl { private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); public void beepForAnHour() { final Runnable beeper = new Runnable() { public void run() { System.out.println("beep"); } }; final ScheduledFuture<?> beeperHandle = scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS); scheduler.schedule(new Runnable() { public void run() { beeperHandle.cancel(true); } }, 60 * 60, SECONDS); } }
ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); final Future handler = executor.submit(new Callable(){ ... }); executor.schedule(new Runnable(){ public void run(){ handler.cancel(); } }, 10000, TimeUnit.MILLISECONDS);
public ChannelListener(final int threadPoolSize, final StreamConsumerFactory consumerFactory, final BufferPool bufferPool, int timeout, TimeUnit unit, final boolean readSingleDatagram) throws IOException { this.executor = Executors.newScheduledThreadPool(threadPoolSize + 1); // need to allow for long running ChannelDispatcher thread this.serverSocketSelector = Selector.open(); this.socketChannelSelector = Selector.open(); this.bufferPool = bufferPool; this.initialBufferPoolSize = bufferPool.size(); channelDispatcher = new ChannelDispatcher(serverSocketSelector, socketChannelSelector, executor, consumerFactory, bufferPool, timeout, unit, readSingleDatagram); executor.schedule(channelDispatcher, 50, TimeUnit.MILLISECONDS); }
@PostConstruct public void init() { allEnvs = portalSettings.getAllEnvs(); //init restTemplate restTemplate = restTemplateFactory.getObject(); refreshServiceAddressService = Executors.newScheduledThreadPool(1, ApolloThreadFactory.create("ServiceLocator", true)); refreshServiceAddressService.schedule(new RefreshAdminServerAddressTask(), 1, TimeUnit.MILLISECONDS); }
static TestCondition createAndSignalAfter(long delay, TimeUnit unit) { final TestCondition testCondition = create(); ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(1); // If signal() fails somehow, we should see a failed test, even without looking at the Future. Future<?> unused = scheduledPool.schedule( new Runnable() { @Override public void run() { testCondition.signal(); } }, delay, unit); return testCondition; }
ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1); MyTask myTask; volatile boolean isStopIssued; executorService.schedule(taskWrapper, delay, TimeUnit.SECONDS);
final ScheduledExecutorService pool = Executors.newScheduledThreadPool(numThreads); final CountDownLatch latch = new CountDownLatch(numThreads); pool.schedule(task, period, periodTimeUnit);
final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(numThreads); @SuppressWarnings("unchecked") final Future<Throwable>[] futures = new Future[iterations]; for (int i = 0; i < iterations; i++) { final Future<Throwable> future = executorService.schedule(new RunProcessor(), i * runSchedule, TimeUnit.MILLISECONDS); futures[i] = future;
1, serverConfig.getRemoteRegionFetchThreadPoolSize(), 0, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); // use direct handoff scheduler = Executors.newScheduledThreadPool(1, new ThreadFactoryBuilder() .setNameFormat("Eureka-RemoteRegionCacheRefresher_" + regionName + "-%d") .build()); scheduler.schedule( new TimedSupervisorTask( "RemoteRegionFetch_" + regionName,
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
scheduler = Executors.newScheduledThreadPool(1); scheduler.schedule(new Runnable() { @Override public void run() {
@Test public void testDetectNewFile() throws IOException, InterruptedException { runner.setProperty(TailFile.BASE_DIRECTORY, "target"); runner.setProperty(TailFile.MODE, TailFile.MODE_MULTIFILE); runner.setProperty(TailFile.LOOKUP_FREQUENCY, "1 sec"); runner.setProperty(TailFile.FILENAME, "log_[0-9]*\\.txt"); runner.setProperty(TailFile.RECURSIVE, "false"); initializeFile("target/log_1.txt", "firstLine\n"); Runnable task = () -> { try { initializeFile("target/log_2.txt", "newFile\n"); } catch (Exception e) { fail(); } }; ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); executor.schedule(task, 2, TimeUnit.SECONDS); runner.setRunSchedule(2000); runner.run(3); runner.assertAllFlowFilesTransferred(TailFile.REL_SUCCESS, 2); assertTrue(runner.getFlowFilesForRelationship(TailFile.REL_SUCCESS).stream().anyMatch(mockFlowFile -> mockFlowFile.isContentEqual("firstLine\n"))); assertTrue(runner.getFlowFilesForRelationship(TailFile.REL_SUCCESS).stream().anyMatch(mockFlowFile -> mockFlowFile.isContentEqual("newFile\n"))); runner.shutdown(); }
private static void test1() throws InterruptedException { ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); Runnable task = () -> System.out.println("Scheduling: " + System.nanoTime()); int delay = 3; ScheduledFuture<?> future = executor.schedule(task, delay, TimeUnit.SECONDS); TimeUnit.MILLISECONDS.sleep(1337); long remainingDelay = future.getDelay(TimeUnit.MILLISECONDS); System.out.printf("Remaining Delay: %sms\n", remainingDelay); }
final Duration timeout = Duration.ofSeconds(30); ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); final Future<String> handler = executor.submit(new Callable() { @Override public String call() throws Exception { return requestDataFromModem(); } }); executor.schedule(new Runnable() { @Override public void run(){ handler.cancel(true); } }, timeout.toMillis(), TimeUnit.MILLISECONDS); executor.shutdownNow();
private final ScheduledExecutorService sched = Executors.newScheduledThreadPool(1); private final ConcurrentHashMap<T, TimerTask> delayedMap = new ConcurrentHashMap<T, TimerTask>(); private final Callback<T> callback; prev = delayedMap.putIfAbsent(key, task); if (prev == null) sched.schedule(task, interval, TimeUnit.MILLISECONDS); } while (prev != null && !prev.extend()); // Exit only if new task was added to map, or existing task was extended successfully long remaining = dueTime - System.currentTimeMillis(); if (remaining > 0) { // Re-schedule task sched.schedule(this, remaining, TimeUnit.MILLISECONDS); } else { // Mark as terminated and invoke callback dueTime = -1;
private void btnSubmitTimerActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_btnSubmitTimerActionPerformed ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5); timeToSubmit = 60; this.btnSubmitTimer.setEnabled(false); ScheduledFuture scheduledFuture = scheduledExecutorService.schedule((Callable) () -> { if (updateDeckTask != null) { updateDeckTask.cancel(true); } if (SessionHandler.submitDeck(tableId, deck.getDeckCardLists())) { removeDeckEditor(); } return null; }, 60, TimeUnit.SECONDS); }//GEN-LAST:event_btnSubmitTimerActionPerformed
ScheduledExecutorService e = Executors.newScheduledThreadPool(10) private final long defaultWaitTimeInMinutes = 1; public void submitTaskToWait(Runnable r){ e.schedule(r, defaultWaitTimeInMinutes, TimeUnit.MINUTES); }