public void runExample() throws Exception { _serviceScheduler = Executors.newScheduledThreadPool(2); final int numCores = Runtime.getRuntime().availableProcessors(); final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(numCores + 1); final EngineBuilder builder = new EngineBuilder().setTaskExecutor(scheduler).setTimerScheduler(scheduler); customizeEngine(builder); final Engine engine = builder.build(); try { doRunExample(engine); } finally { engine.shutdown(); scheduler.shutdownNow(); _serviceScheduler.shutdown(); _serviceScheduler = null; } }
@AfterMethod public void tearDown() throws Exception { _engine.shutdown(); _engine.awaitTermination(50, TimeUnit.MILLISECONDS); _engine = null; _scheduler.shutdownNow(); _scheduler = null; }
@AfterMethod public void tearDown() throws Exception { _engine.shutdown(); _engine.awaitTermination(50, TimeUnit.MILLISECONDS); _engine = null; _scheduler.shutdownNow(); _scheduler = null; }
public void runExample() throws Exception { _serviceScheduler = Executors.newScheduledThreadPool(2); final int numCores = Runtime.getRuntime().availableProcessors(); final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(numCores + 1); final Engine engine = new EngineBuilder() .setTaskExecutor(scheduler) .setTimerScheduler(scheduler) .build(); try { doRunExample(engine); } finally { engine.shutdown(); scheduler.shutdownNow(); _serviceScheduler.shutdown(); _serviceScheduler = null; } }
@AfterMethod public void tearDown() throws Exception { _engine.shutdown(); _engine.awaitTermination(50, TimeUnit.MILLISECONDS); _engine = null; _scheduler.shutdownNow(); _scheduler = null; }
public void runExample(BenchmarkConfig config) throws Exception { final int numCores = Runtime.getRuntime().availableProcessors(); final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(numCores - 1, new ThreadFactory() { @Override public Thread newThread(Runnable r) { Thread t = new Thread(r); _parseqThreads.add(t); return t; } }); final EngineBuilder builder = new EngineBuilder().setTaskExecutor(scheduler).setTimerScheduler(scheduler); builder.setPlanDeactivationListener(_batchingSupport); builder.setEngineProperty(Engine.MAX_CONCURRENT_PLANS, config.CONCURRENCY_LEVEL); final Engine engine = builder.build(); try { doRunBenchmark(engine, config); } finally { engine.shutdown(); scheduler.shutdownNow(); } }
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(); } } }
engine.shutdown(); scheduler.shutdownNow();
@Test public void testShutdownThenRunTask() throws InterruptedException { _engine.shutdown(); final Task<String> task = Task.value("task executed"); _engine.run(task); // Task should be cancelled immediately assertTrue(task.await(50, TimeUnit.MILLISECONDS)); assertTrue(task.isFailed()); }
@Test public void testShutdownWithNoTasks() throws InterruptedException { _engine.shutdown(); assertTrue(_engine.isShutdown()); assertTrue(_engine.awaitTermination(50, TimeUnit.MILLISECONDS)); assertTrue(_engine.isTerminated()); assertTrue(_engine.isShutdown()); }
@AfterClass public void shutdown() throws Exception { if (_server != null) { _server.stop(); } if (_serverEngine != null) { _serverEngine.shutdown(); } if (_serverScheduler != null) { _serverScheduler.shutdownNow(); } for (Client client : _transportClients) { FutureCallback<None> callback = new FutureCallback<>(); client.shutdown(callback); callback.get(); } if (_clientFactory != null) { FutureCallback<None> callback = new FutureCallback<>(); _clientFactory.shutdown(callback); callback.get(); } }
task.getError().getCause().getCause() instanceof RejectedExecutionException); engine.shutdown(); } finally { scheduledExecutorService.shutdownNow();
@SuppressWarnings("deprecation") @Test public void testTaskWithoutExecutor() throws InterruptedException { final int numCores = Runtime.getRuntime().availableProcessors(); final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(numCores + 1); final Engine engine = new EngineBuilder().setTaskExecutor(scheduler).setTimerScheduler(scheduler).build(); try { final Task<Integer> task = new AsyncCallableTask<Integer>(new Callable<Integer>() { @Override public Integer call() throws Exception { return 1; } }); engine.run(task); assertTrue(task.await(5, TimeUnit.SECONDS)); assertTrue(task.isFailed()); assertTrue(task.getError() instanceof IllegalStateException); } finally { engine.shutdown(); engine.awaitTermination(1, TimeUnit.SECONDS); scheduler.shutdownNow(); } } }
@Test public void testShutdownWithRunningTask() throws InterruptedException { final CountDownLatch finishLatch = new CountDownLatch(1); final String taskValue = "task executed"; final Task<String> task = new BaseTask<String>() { @Override protected Promise<? extends String> run(final Context context) throws Exception { finishLatch.await(); return Promises.value(taskValue); } }; _engine.run(task); _engine.shutdown(); // shutdown should not complete until after our task is done assertFalse(_engine.awaitTermination(50, TimeUnit.MILLISECONDS)); assertTrue(_engine.isShutdown()); assertFalse(_engine.isTerminated()); finishLatch.countDown(); assertTrue(_engine.awaitTermination(50, TimeUnit.MILLISECONDS)); assertTrue(_engine.isShutdown()); assertTrue(_engine.isTerminated()); // Task should finish shortly assertTrue(task.await(50, TimeUnit.MILLISECONDS)); assertEquals(taskValue, task.get()); }
@Test public void testShutdownWithSideEffectTask() throws InterruptedException { final CountDownLatch finishLatch = new CountDownLatch(1); final String mainValue = "main task executed"; final String sideEffectValue = "side-effect task executed"; Task<String> sideEffect = Task.async(context -> { finishLatch.await(); return Promises.value(sideEffectValue); }); Task<String> task = Task.value(mainValue).withSideEffect(v -> sideEffect); _engine.run(task); _engine.shutdown(); assertFalse(_engine.awaitTermination(50, TimeUnit.MILLISECONDS)); assertTrue(_engine.isShutdown()); assertFalse(_engine.isTerminated()); finishLatch.countDown(); assertTrue(_engine.awaitTermination(50, TimeUnit.MILLISECONDS)); assertTrue(_engine.isShutdown()); assertTrue(_engine.isTerminated()); assertEquals(mainValue, task.get()); assertEquals(sideEffectValue, sideEffect.get()); }
@Test public void testShutdownWithRunningAndSuccessorTask() throws InterruptedException { final CountDownLatch finishLatch = new CountDownLatch(1); final String predValue = "task executed"; final String sucValue = "task executed"; final Task<String> predTask = new BaseTask<String>() { @Override protected Promise<? extends String> run(final Context context) throws Exception { finishLatch.await(); return Promises.value(predValue); } }; final Task<String> sucTask = Task.value(sucValue); final Task<String> seq = predTask.andThen(sucTask); _engine.run(seq); _engine.shutdown(); // shutdown should not complete until after our task is done assertFalse(_engine.awaitTermination(50, TimeUnit.MILLISECONDS)); assertTrue(_engine.isShutdown()); assertFalse(_engine.isTerminated()); finishLatch.countDown(); assertTrue(_engine.awaitTermination(50, TimeUnit.MILLISECONDS)); assertTrue(_engine.isShutdown()); assertTrue(_engine.isTerminated()); // Tasks should finish shortly assertTrue(predTask.await(50, TimeUnit.MILLISECONDS)); assertEquals(predValue, predTask.get()); assertTrue(sucTask.await(50, TimeUnit.MILLISECONDS)); assertEquals(sucValue, sucTask.get()); }
@Test public void testShutdownWithSideEffectTask2() throws InterruptedException { final SettablePromise<String> sideEffectPromise = Promises.settable(); final String mainValue = "main task executed"; final String sideEffectValue = "side-effect task executed"; Task<String> sideEffect = Task.async(context -> sideEffectPromise); Task<String> task = Task.value(mainValue).withSideEffect(v -> sideEffect); _engine.run(task); _engine.shutdown(); assertFalse(_engine.awaitTermination(50, TimeUnit.MILLISECONDS)); assertTrue(_engine.isShutdown()); assertFalse(_engine.isTerminated()); sideEffectPromise.done(sideEffectValue); assertTrue(_engine.awaitTermination(50, TimeUnit.MILLISECONDS)); assertTrue(_engine.isShutdown()); assertTrue(_engine.isTerminated()); assertEquals(mainValue, task.get()); assertEquals(sideEffectValue, sideEffect.get()); }
@Override public void stop() throws IOException { server.stop(); engine.shutdown(); executor.shutdown(); scheduler.shutdown(); }
public static void main(String[] args) throws IOException { final int numCores = Runtime.getRuntime().availableProcessors(); final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(numCores + 1); final Engine engine = new EngineBuilder() .setTaskExecutor(scheduler) .setTimerScheduler(scheduler) .build(); HttpServer server = createServer(engine, DEFAULT_PORT, supportedCompression); server.start(); System.out.println("HttpServer running on port " + DEFAULT_PORT + ". Press any key to stop server"); System.in.read(); server.stop(); engine.shutdown(); }
server.stop(); _graphvizEngine.stop(); engine.shutdown(); scheduler.shutdownNow(); HttpClient.close();