How to use

shutdown

method

in

com.linkedin.parseq.Engine

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();