private void initFlushThread() { flushThreadPool = Executors.newScheduledThreadPool(1); flushThreadPool.scheduleAtFixedRate(new Runnable() { @Override public void run() { flush(); } }, 10, 10, TimeUnit.SECONDS); }
private synchronized void planNextTry(long afterMillis) { if (scheduledExecutorService == null) { scheduledExecutorService = Executors.newScheduledThreadPool(1); } scheduledExecutorService.schedule(this::tryPublish, afterMillis, TimeUnit.MILLISECONDS); }
Runnable helloRunnable = new Runnable() { public void run() { System.out.println("Hello world"); } }; ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); executor.scheduleAtFixedRate(helloRunnable, 0, 3, TimeUnit.SECONDS);
public static void main(String[] args) throws InterruptedException { final long viewerId = 0; final Set<Long> unclassified = new HashSet<Long>(); for (long i = 0; i < 20; i++) { unclassified.add(i); } final ScheduledExecutorService serviceScheduler = Executors.newSingleThreadScheduledExecutor(); final Client restLiClient = new ClientImpl(serviceScheduler); final int numCores = Runtime.getRuntime().availableProcessors(); final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(numCores + 1); final Engine engine = new EngineBuilder().setTaskExecutor(scheduler).setTimerScheduler(scheduler).build(); final ClassifierPlanFactory classifier = new ClassifierPlanFactory(restLiClient); try { final Task<Map<Long, Classification>> classifications = classifier.classify(viewerId, unclassified); engine.run(classifications); classifications.await(); System.out.println(classifications.get()); ExampleUtil.printTracingResults(classifications); } finally { serviceScheduler.shutdownNow(); engine.shutdown(); scheduler.shutdownNow(); } } }
public static void usingScheduledThreadPool() { System.out.println("=== ScheduledThreadPool ==="); ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4); scheduledThreadPool.scheduleAtFixedRate( () -> System.out.println("Print every 2s"), 0, 2, TimeUnit.SECONDS); scheduledThreadPool.scheduleWithFixedDelay( () -> System.out.println("Print every 2s delay"), 0, 2, TimeUnit.SECONDS); try { scheduledThreadPool.awaitTermination(6, TimeUnit.SECONDS); scheduledThreadPool.shutdown(); } catch (InterruptedException e) { e.printStackTrace(); } }
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); }
System.out.println("sampling started"); CLASS=className; METHOD=method; EXECUTOR = Executors.newScheduledThreadPool(1); if(t==null) System.out.println("method not seen"); else printCallTree(t, 0, 100); sb.append(chPercent).append("% (").append(cht.cpu*percent/num) .append("% cpu) ").append(ch.getKey()).append(" "); System.out.println(sb.toString()); printCallTree(cht, ind+2, chPercent);
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); } }
public TestScanFilterAndProjectOperator() { executor = newCachedThreadPool(daemonThreadsNamed("test-executor-%s")); scheduledExecutor = newScheduledThreadPool(2, daemonThreadsNamed("test-scheduledExecutor-%s")); }
cacheUpdateMaster = Executors.newScheduledThreadPool(1, new ThreadFactory() { @Override public Thread newThread(Runnable r) { cacheUpdateMaster.scheduleAtFixedRate(new CacheUpdateMasterWork(conf, shouldRunPrewarm), 0, cacheRefreshPeriodMS, TimeUnit.MILLISECONDS); cacheUpdateMaster.schedule(new CacheUpdateMasterWork(conf, shouldRunPrewarm), 0, TimeUnit.MILLISECONDS);
@Provides @Singleton @ForExchange public static ScheduledExecutorService createExchangeExecutor(ExchangeClientConfig config) { return newScheduledThreadPool(config.getClientThreads(), daemonThreadsNamed("exchange-client-%s")); }
public static void main(String[] args) throws InterruptedException { ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1); Runnable r = new Runnable() { @Override public void run() { System.out.println("Hello"); } }; ScheduledFuture<?> scheduledFuture = scheduledExecutorService.scheduleAtFixedRate(r, 1L, 1L, TimeUnit.SECONDS); Thread.sleep(5000L); scheduledFuture.cancel(false); }
final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(numCores + 1); final Engine engine = new EngineBuilder() .setTaskExecutor(scheduler) engine.run(classifications); classifications.await(); System.out.println(classifications.get());
ScheduledExecutorService scheduler = Executors .newScheduledThreadPool(1); ScheduledFuture<String> future = scheduler.schedule( new ScheduledPrinter(), 10, TimeUnit.SECONDS); System.out.println(future.get());
private static void test3() { ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); Runnable task = () -> { try { TimeUnit.SECONDS.sleep(2); System.out.println("Scheduling: " + System.nanoTime()); } catch (InterruptedException e) { System.err.println("task interrupted"); } }; executor.scheduleWithFixedDelay(task, 0, 1, TimeUnit.SECONDS); }
@BeforeClass public void setUp() { executor = newCachedThreadPool(daemonThreadsNamed("test-executor-%s")); scheduledExecutor = newScheduledThreadPool(2, daemonThreadsNamed("test-scheduledExecutor-%s")); }
private static void loop(ProgressMonitor progressMonitor, long interval) { final ProgressMonitor monitor = progressMonitor; Runnable runner = new Runnable() { public void run() { try { monitor.exportStats(); } catch (Throwable t) { LOG.error("Progress monitor failed", t); } } }; ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1); scheduler.scheduleAtFixedRate(runner, 0, interval, TimeUnit.SECONDS); }
/** * 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(); }
@BeforeClass public void setUp() { stateNotificationExecutor = newScheduledThreadPool(5, daemonThreadsNamed("test-%s")); }
private static void test2() { ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); Runnable task = () -> System.out.println("Scheduling: " + System.nanoTime()); int initialDelay = 0; int period = 1; executor.scheduleAtFixedRate(task, initialDelay, period, TimeUnit.SECONDS); }