Tabnine Logo
Engine.shutdown
Code IndexAdd Tabnine to your IDE (free)

How to use
shutdown
method
in
com.linkedin.parseq.Engine

Best Java code snippets using com.linkedin.parseq.Engine.shutdown (Showing top 20 results out of 315)

origin: linkedin/parseq

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;
 }
}
origin: linkedin/parseq

@AfterMethod
public void tearDown() throws Exception {
 _engine.shutdown();
 _engine.awaitTermination(50, TimeUnit.MILLISECONDS);
 _engine = null;
 _scheduler.shutdownNow();
 _scheduler = null;
}
origin: linkedin/parseq

@AfterMethod
public void tearDown() throws Exception {
 _engine.shutdown();
 _engine.awaitTermination(50, TimeUnit.MILLISECONDS);
 _engine = null;
 _scheduler.shutdownNow();
 _scheduler = null;
}
origin: linkedin/parseq

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;
 }
}
origin: linkedin/parseq

@AfterMethod
public void tearDown() throws Exception {
 _engine.shutdown();
 _engine.awaitTermination(50, TimeUnit.MILLISECONDS);
 _engine = null;
 _scheduler.shutdownNow();
 _scheduler = null;
}
origin: linkedin/parseq

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();
 }
}
origin: linkedin/parseq

 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();
  }
 }
}
origin: linkedin/parseq

engine.shutdown();
scheduler.shutdownNow();
origin: linkedin/parseq

@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());
}
origin: linkedin/parseq

@Test
public void testShutdownWithNoTasks() throws InterruptedException {
 _engine.shutdown();
 assertTrue(_engine.isShutdown());
 assertTrue(_engine.awaitTermination(50, TimeUnit.MILLISECONDS));
 assertTrue(_engine.isTerminated());
 assertTrue(_engine.isShutdown());
}
origin: linkedin/parseq

@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();
 }
}
origin: linkedin/parseq

   task.getError().getCause().getCause() instanceof RejectedExecutionException);
 engine.shutdown();
} finally {
 scheduledExecutorService.shutdownNow();
origin: linkedin/parseq

 @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();
  }
 }
}
origin: linkedin/parseq

@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());
}
origin: linkedin/parseq

@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());
}
origin: linkedin/parseq

@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());
}
origin: linkedin/parseq

@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());
}
origin: com.linkedin.pegasus/restli-server-testutils

@Override
public void stop()
  throws IOException
{
 server.stop();
 engine.shutdown();
 executor.shutdown();
 scheduler.shutdown();
}
origin: com.linkedin.pegasus/restli-int-test-server

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();
}
origin: com.linkedin.parseq/parseq-tracevis-server

server.stop();
_graphvizEngine.stop();
engine.shutdown();
scheduler.shutdownNow();
HttpClient.close();
com.linkedin.parseqEngineshutdown

Javadoc

If the engine is currently running, this method will initiate an orderly shutdown. No new tasks will be accepted, but already running tasks will be allowed to finish. Use #awaitTermination(int,java.util.concurrent.TimeUnit)to wait for the engine to shutdown.

If the engine is already shutting down or stopped this method will have no effect.

Popular methods of Engine

  • run
    Runs the given task. Task passed in as a parameter becomes a root on a new Plan. All tasks created a
  • blockingRun
    Runs the given task. Task passed in as a parameter becomes a root on a new Plan. All tasks created a
  • tryRun
    Runs the given task if Engine has a capacity to start new plan as specified by #MAX_CONCURRENT_PLANS
  • <init>
  • acquirePermit
  • createTaskQueueFactory
  • defaultPlanClass
  • getProperty
  • runWithPermit
    Runs the given task with its own context. Use Tasks.seq and Tasks.par to create and run composite ta
  • tryAcquirePermit
  • tryTransitionShutdown
  • tryTransitionTerminate
  • tryTransitionShutdown,
  • tryTransitionTerminate,
  • awaitTermination,
  • isShutdown,
  • isTerminated

Popular in Java

  • Making http requests using okhttp
  • getExternalFilesDir (Context)
  • scheduleAtFixedRate (ScheduledExecutorService)
  • addToBackStack (FragmentTransaction)
  • Runnable (java.lang)
    Represents a command that can be executed. Often used to run code in a different Thread.
  • ServerSocket (java.net)
    This class represents a server-side socket that waits for incoming client connections. A ServerSocke
  • HashMap (java.util)
    HashMap is an implementation of Map. All optional operations are supported.All elements are permitte
  • List (java.util)
    An ordered collection (also known as a sequence). The user of this interface has precise control ove
  • Response (javax.ws.rs.core)
    Defines the contract between a returned instance and the runtime when an application needs to provid
  • Table (org.hibernate.mapping)
    A relational table
  • Top Sublime Text plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now