List of usage examples for java.util.concurrent ScheduledExecutorService submit
<T> Future<T> submit(Callable<T> task);
From source file:org.trendafilov.odesk.notifier.Main.java
public void startup() { ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); executor.scheduleAtFixedRate(alertDeamon, 1, 1, TimeUnit.MINUTES); while (true) { executor.submit(newJobPooler); int randomDelay = 3 + (int) (Math.random() * 5); Logger.info(String.format("Sleeping for: [%s]", randomDelay)); try {// w w w . j a v a 2s . c o m Thread.sleep(randomDelay * 1000 * 60); } catch (InterruptedException e) { throw new RuntimeException(e); } } }
From source file:amqp.spring.camel.component.ContrivedLoadTest.java
@Test public void testSynchronous() throws Exception { final int messageCount = 1000; int received = 0; ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(messageCount); List<Future<String>> futures = new ArrayList<Future<String>>(); long startTime = System.currentTimeMillis(); for (int i = 0; i < messageCount; ++i) futures.add(executorService.submit(new SynchronousRequestor(this.template))); LOG.info("Time to submit synchronous messages: {}", (System.currentTimeMillis() - startTime) / 1000.0f); startTime = System.currentTimeMillis(); for (Future<String> future : futures) { String response = future.get(10000, TimeUnit.MILLISECONDS); if ("RESPONSE".equals(response)) ++received;/*from ww w . j a va 2s.c om*/ } float elapsedTime = (System.currentTimeMillis() - startTime) / 1000.0f; int maxPoolSize = this.camelContext.getExecutorServiceManager().getDefaultThreadPoolProfile() .getMaxPoolSize(); LOG.info("Time to receive synchronous messages: {}", elapsedTime); Assert.assertEquals(messageCount, received); //Assuming 1 second delay per message, elapsed time shouldn't exceed the number of messages sent //dividied by the number of messages that can be simultaneously consumed. Assert.assertTrue( String.format("Possible performance issue: %d messages took %f seconds with %d consumers", messageCount, elapsedTime, maxPoolSize), elapsedTime < (messageCount / (double) maxPoolSize) + 1); }
From source file:org.elasticsearch.client.sniff.SnifferTests.java
/** * Test behaviour when a bunch of onFailure sniffing rounds are triggered in parallel. Each run will always * schedule a subsequent afterFailure round. Also, for each onFailure round that starts, the net scheduled round * (either afterFailure or ordinary) gets cancelled. *//*from ww w.j a v a 2s . c o m*/ public void testSniffOnFailure() throws Exception { RestClient restClient = mock(RestClient.class); CountingHostsSniffer hostsSniffer = new CountingHostsSniffer(); final AtomicBoolean initializing = new AtomicBoolean(true); final long sniffInterval = randomLongBetween(1, Long.MAX_VALUE); final long sniffAfterFailureDelay = randomLongBetween(1, Long.MAX_VALUE); int minNumOnFailureRounds = randomIntBetween(5, 10); final CountDownLatch initializingLatch = new CountDownLatch(1); final Set<Sniffer.ScheduledTask> ordinaryRoundsTasks = new CopyOnWriteArraySet<>(); final AtomicReference<Future<?>> initializingFuture = new AtomicReference<>(); final Set<Sniffer.ScheduledTask> onFailureTasks = new CopyOnWriteArraySet<>(); final Set<Sniffer.ScheduledTask> afterFailureTasks = new CopyOnWriteArraySet<>(); final AtomicBoolean onFailureCompleted = new AtomicBoolean(false); final CountDownLatch completionLatch = new CountDownLatch(1); final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); try { Scheduler scheduler = new Scheduler() { @Override public Future<?> schedule(final Sniffer.Task task, long delayMillis) { if (initializing.compareAndSet(true, false)) { assertEquals(0L, delayMillis); Future<?> future = executor.submit(new Runnable() { @Override public void run() { try { task.run(); } finally { //we need to make sure that the sniffer is initialized, so the sniffOnFailure //call does what it needs to do. Otherwise nothing happens until initialized. initializingLatch.countDown(); } } }); assertTrue(initializingFuture.compareAndSet(null, future)); return future; } if (delayMillis == 0L) { Future<?> future = executor.submit(task); onFailureTasks.add(new Sniffer.ScheduledTask(task, future)); return future; } if (delayMillis == sniffAfterFailureDelay) { Future<?> future = scheduleOrSubmit(task); afterFailureTasks.add(new Sniffer.ScheduledTask(task, future)); return future; } assertEquals(sniffInterval, delayMillis); assertEquals(sniffInterval, task.nextTaskDelay); if (onFailureCompleted.get() && onFailureTasks.size() == afterFailureTasks.size()) { completionLatch.countDown(); return mock(Future.class); } Future<?> future = scheduleOrSubmit(task); ordinaryRoundsTasks.add(new Sniffer.ScheduledTask(task, future)); return future; } private Future<?> scheduleOrSubmit(Sniffer.Task task) { if (randomBoolean()) { return executor.schedule(task, randomLongBetween(0L, 200L), TimeUnit.MILLISECONDS); } else { return executor.submit(task); } } @Override public void shutdown() { } }; final Sniffer sniffer = new Sniffer(restClient, hostsSniffer, scheduler, sniffInterval, sniffAfterFailureDelay); assertTrue("timeout waiting for sniffer to get initialized", initializingLatch.await(1000, TimeUnit.MILLISECONDS)); ExecutorService onFailureExecutor = Executors.newFixedThreadPool(randomIntBetween(5, 20)); Set<Future<?>> onFailureFutures = new CopyOnWriteArraySet<>(); try { //with tasks executing quickly one after each other, it is very likely that the onFailure round gets skipped //as another round is already running. We retry till enough runs get through as that's what we want to test. while (onFailureTasks.size() < minNumOnFailureRounds) { onFailureFutures.add(onFailureExecutor.submit(new Runnable() { @Override public void run() { sniffer.sniffOnFailure(); } })); } assertThat(onFailureFutures.size(), greaterThanOrEqualTo(minNumOnFailureRounds)); for (Future<?> onFailureFuture : onFailureFutures) { assertNull(onFailureFuture.get()); } onFailureCompleted.set(true); } finally { onFailureExecutor.shutdown(); onFailureExecutor.awaitTermination(1000, TimeUnit.MILLISECONDS); } assertFalse(initializingFuture.get().isCancelled()); assertTrue(initializingFuture.get().isDone()); assertNull(initializingFuture.get().get()); assertTrue("timeout waiting for sniffing rounds to be completed", completionLatch.await(1000, TimeUnit.MILLISECONDS)); assertThat(onFailureTasks.size(), greaterThanOrEqualTo(minNumOnFailureRounds)); assertEquals(onFailureTasks.size(), afterFailureTasks.size()); for (Sniffer.ScheduledTask onFailureTask : onFailureTasks) { assertFalse(onFailureTask.future.isCancelled()); assertTrue(onFailureTask.future.isDone()); assertNull(onFailureTask.future.get()); assertTrue(onFailureTask.task.hasStarted()); assertFalse(onFailureTask.task.isSkipped()); } int cancelledTasks = 0; int completedTasks = onFailureTasks.size() + 1; for (Sniffer.ScheduledTask afterFailureTask : afterFailureTasks) { if (assertTaskCancelledOrCompleted(afterFailureTask)) { completedTasks++; } else { cancelledTasks++; } } assertThat(ordinaryRoundsTasks.size(), greaterThan(0)); for (Sniffer.ScheduledTask task : ordinaryRoundsTasks) { if (assertTaskCancelledOrCompleted(task)) { completedTasks++; } else { cancelledTasks++; } } assertEquals(onFailureTasks.size(), cancelledTasks); assertEquals(completedTasks, hostsSniffer.runs.get()); int setHostsRuns = hostsSniffer.runs.get() - hostsSniffer.failures.get() - hostsSniffer.emptyList.get(); verify(restClient, times(setHostsRuns)).setHosts(Matchers.<HttpHost>anyVararg()); verifyNoMoreInteractions(restClient); } finally { executor.shutdown(); executor.awaitTermination(1000L, TimeUnit.MILLISECONDS); } }
From source file:org.elasticsearch.client.sniff.SnifferTests.java
public void testTaskCancelling() throws Exception { RestClient restClient = mock(RestClient.class); HostsSniffer hostsSniffer = mock(HostsSniffer.class); Scheduler noOpScheduler = new Scheduler() { @Override/* w w w . j a va2 s . c om*/ public Future<?> schedule(Sniffer.Task task, long delayMillis) { return null; } @Override public void shutdown() { } }; Sniffer sniffer = new Sniffer(restClient, hostsSniffer, noOpScheduler, 0L, 0L); ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); try { int numIters = randomIntBetween(50, 100); for (int i = 0; i < numIters; i++) { Sniffer.Task task = sniffer.new Task(0L); TaskWrapper wrapper = new TaskWrapper(task); Future<?> future; if (rarely()) { future = executor.schedule(wrapper, randomLongBetween(0L, 200L), TimeUnit.MILLISECONDS); } else { future = executor.submit(wrapper); } Sniffer.ScheduledTask scheduledTask = new Sniffer.ScheduledTask(task, future); boolean skip = scheduledTask.skip(); try { assertNull(future.get()); } catch (CancellationException ignore) { assertTrue(future.isCancelled()); } if (skip) { //the task was either cancelled before starting, in which case it will never start (thanks to Future#cancel), //or skipped, in which case it will run but do nothing (thanks to Task#skip). //Here we want to make sure that whenever skip returns true, the task either won't run or it won't do anything, //otherwise we may end up with parallel sniffing tracks given that each task schedules the following one. We need to // make sure that onFailure takes scheduling over while at the same time ordinary rounds don't go on. assertFalse(task.hasStarted()); assertTrue(task.isSkipped()); assertTrue(future.isCancelled()); assertTrue(future.isDone()); } else { //if a future is cancelled when its execution has already started, future#get throws CancellationException before //completion. The execution continues though so we use a latch to try and wait for the task to be completed. //Here we want to make sure that whenever skip returns false, the task will be completed, otherwise we may be //missing to schedule the following round, which means no sniffing will ever happen again besides on failure sniffing. assertTrue(wrapper.await()); //the future may or may not be cancelled but the task has for sure started and completed assertTrue(task.toString(), task.hasStarted()); assertFalse(task.isSkipped()); assertTrue(future.isDone()); } //subsequent cancel calls return false for sure int cancelCalls = randomIntBetween(1, 10); for (int j = 0; j < cancelCalls; j++) { assertFalse(scheduledTask.skip()); } } } finally { executor.shutdown(); executor.awaitTermination(1000, TimeUnit.MILLISECONDS); } }
From source file:org.akubraproject.rmi.TransactionalStoreTest.java
@Test public void testMTStress() throws InterruptedException, ExecutionException { ScheduledExecutorService executor = Executors.newScheduledThreadPool(10); List<Future<Void>> futures = new ArrayList<Future<Void>>(); for (int loop = 0; loop < 30; loop++) { futures.add(executor.submit(new Callable<Void>() { public Void call() throws Exception { for (int i = 0; i < 10; i++) { doInTxn(new Action() { public void run(BlobStoreConnection con) throws Exception { for (int j = 0; j < 3; j++) { URI id = URI.create("urn:mt:" + UUID.randomUUID()); byte[] buf = new byte[4096]; Blob b; b = con.getBlob(id, null); OutputStream out; IOUtils.copyLarge(new ByteArrayInputStream(buf), out = b.openOutputStream(buf.length, true)); out.close(); InputStream in; assertEquals(buf, IOUtils.toByteArray(in = b.openInputStream())); in.close(); b.delete(); }//from w w w . j a va 2s .c o m } }, true); } return null; } })); } for (Future<Void> res : futures) res.get(); }
From source file:org.apache.ambari.servicemonitor.jobs.BulkFileJobSubmitter.java
private int exec() throws Exception { CommandLine commandLine = getCommandLine(); Configuration conf = getConf(); String outputdir = OptionHelper.getStringOption(commandLine, "o", "bulkjob"); outputPath = new Path(outputdir); if (commandLine.hasOption('x')) { //delete the filesystem dir. This will deleteOutputDirectories = true;//from w w w . ja va 2 s.c o m } jobs = OptionHelper.getIntOption(commandLine, "j", 1); int delay = OptionHelper.getIntOption(commandLine, "l", 1000); doneSignal = new CountDownLatch(jobs); templateConf = new JobConf(conf); String jtURI = MonitorUtils.extractJobTrackerParameter(templateConf); LOG.info("Submitting " + (jobs >= 0 ? jobs : "unlimited") + " jobs with a delay of " + delay + " millis" + " to JT " + jtURI + " and filesystem " + templateConf.get(FileSystem.FS_DEFAULT_NAME_KEY)); int jobCount = 0; ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(POOL_SIZE); int toSubmit = jobs; long started, finished; started = System.currentTimeMillis(); while (toSubmit > 0) { scheduler.submit(new JobWorker("instance-" + (++jobCount))); Thread.sleep(delay); toSubmit--; } LOG.info("All jobs scheduled in local queue"); //here all the jobs are submitted, await their completion. doneSignal.await(); finished = System.currentTimeMillis(); int s = successes.get(); int f = failures.get(); long execDuration = totalExecDuration.get(); long elapsedTime = finished - started; LOG.info("Completed. Successes = " + s + " out of " + jobs + " success rate= " + (s * 100) / (jobs) + "% " + " total execTime " + MonitorUtils.millisToHumanTime(execDuration) + " " + " elapsed Time " + MonitorUtils.millisToHumanTime(elapsedTime)); return f == 0 ? 0 : 1; }
From source file:org.janusgraph.TestBed.java
/** * @param args/*from ww w . j a va 2 s . co m*/ * @throws java.io.IOException */ public static void main(String[] args) throws Exception { Method method = TestBed.class.getMethod("getInt", int.class, int.class); AnnotatedType rt = method.getAnnotatedReturnType(); System.out.println(rt.getType()); System.out.println(rt.getAnnotations().length); System.out.println(method.getAnnotations().length); for (int i = 0; i < method.getAnnotations().length; i++) { System.out.println(method.getAnnotations()[i]); } // String[] s = {"a","b","c","d","e","f","g","h","i","x","u"}; // int len = s.length; // Random random = new Random(); // // Context c = new Context(new ObserverManager(),Observer.NO_OP); // //Warmup // for (int i = 0; i < 1000000000; i++) { // c.observe(s[1],s[2]); // } // long before = System.nanoTime(); // for (int i = 0; i < 1000000000; i++) { // c.observe(s[1],s[2]); // } // long total = System.nanoTime()-before; // System.out.println("Total time: " + total/1000000); System.exit(0); final ScheduledExecutorService exe = new ScheduledThreadPoolExecutor(1, new RejectedExecutionHandler() { @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { r.run(); } }); ScheduledFuture future = exe.scheduleWithFixedDelay(new Runnable() { AtomicInteger atomicInt = new AtomicInteger(0); @Override public void run() { try { for (int i = 0; i < 10; i++) { exe.submit(new Runnable() { private final int number = atomicInt.incrementAndGet(); @Override public void run() { try { Thread.sleep(150); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(number); } }); System.out.println("Submitted: " + i); // doSomethingExpensive(20); } } catch (Exception e) { e.printStackTrace(); } } }, 0, 1, TimeUnit.SECONDS); Thread.sleep(10000); // future.get(1,TimeUnit.SECONDS); System.out.println("Cancel: " + future.cancel(false)); System.out.println("Done: " + future.isDone()); exe.shutdown(); // Thread.sleep(2000); System.out.println("Terminate: " + exe.awaitTermination(5, TimeUnit.SECONDS)); System.out.println("DONE"); NonBlockingHashMapLong<String> id1 = new NonBlockingHashMapLong<String>(128); ConcurrentHashMap<Long, String> id2 = new ConcurrentHashMap<Long, String>(128, 0.75f, 2); }