@Override public ListenableFuture<T> call() throws Exception { return listeningExecutorService.submit(callable); } };
@SuppressWarnings("ParameterPackage") @Override public <T> ListenableFuture<T> submit(Callable<T> tCallable) { return delegate.submit(tCallable); }
/** * Insert a barrier into the merge-and-push queue. When this future resolves, all pending pushes will have finished. * This is useful if we're going to do something that would otherwise potentially break currently in-progress * pushes. */ private ListenableFuture<?> pushBarrier() { return intermediateTempExecutor.submit( (Runnable) () -> pushExecutor.submit(() -> {}) ); }
@Override public ListenableFuture<?> submit(Runnable task) { Preconditions.checkNotNull(task, "task must not be null!"); return delegate.submit(task); }
@Override public <T> ListenableFuture<T> submit(Callable<T> task) { Preconditions.checkNotNull(task, "task must not be null!"); return delegate.submit(task); }
@Override public ListenableFuture<Boolean> reload(final CacheKey key, Boolean oldValue) throws Exception { return listeningCacheReloadExecutor.submit(new Callable<Boolean>() { @Override public Boolean call() throws Exception { return load(key); } }); } });
@Override public <T> ListenableFuture<T> submit(Runnable task, T result) { Preconditions.checkNotNull(task, "task must not be null!"); Preconditions.checkNotNull(result, "result must not be null!"); return delegate.submit(task, result); }
@Override public <T> ListenableFuture<T> submit(Runnable task, T result) { return delegate().submit(task, result); } }
@Override public ListenableFuture<?> submit(Runnable task) { return delegate().submit(task); }
@Override public <T> ListenableFuture<T> submit(Callable<T> task) { return delegate().submit(task); }
@Override public final ListenableFuture<PrestoThriftSplitBatch> getSplits( PrestoThriftSchemaTableName schemaTableName, PrestoThriftNullableColumnSet desiredColumns, PrestoThriftTupleDomain outputConstraint, int maxSplitCount, PrestoThriftNullableToken nextToken) { return executor.submit(() -> getSplitsSync(schemaTableName, maxSplitCount, nextToken)); }
@Override public final ListenableFuture<PrestoThriftSplitBatch> getIndexSplits( PrestoThriftSchemaTableName schemaTableName, List<String> indexColumnNames, List<String> outputColumnNames, PrestoThriftPageResult keys, PrestoThriftTupleDomain outputConstraint, int maxSplitCount, PrestoThriftNullableToken nextToken) { return executor.submit(() -> getIndexSplitsSync(schemaTableName, indexColumnNames, keys, maxSplitCount, nextToken)); }
@Override public ListenableFuture<List<Page>> getAllSpilledPages() { return executor.submit(() -> ImmutableList.copyOf(getSpilledPages())); }
@Override public final ListenableFuture<PrestoThriftPageResult> getRows( PrestoThriftId splitId, List<String> outputColumns, long maxBytes, PrestoThriftNullableToken nextToken) { return executor.submit(() -> getRowsSync(splitId, outputColumns, maxBytes, nextToken)); }
private <I, O> ListenableFuture<Collection<O>> asyncGroupExecute(final ShardingExecuteGroup<I> inputGroup, final ShardingGroupExecuteCallback<I, O> callback) { final Map<String, Object> dataMap = ShardingExecuteDataMap.getDataMap(); return executorService.submit(new Callable<Collection<O>>() { @Override public Collection<O> call() throws SQLException { return callback.execute(inputGroup.getInputs(), false, dataMap); } }); }
private synchronized ListenableFuture<?> abortInternal() { // the callbacks in statement performed on another thread so are safe return nonCancellationPropagating(Futures.allAsList(connectorIdToMetadata.values().stream() .map(connection -> finishingExecutor.submit(() -> safeAbort(connection))) .collect(toList()))); }
/** * Submits the task and adds a listener that adds the future to {@code queue} when it completes. */ @GwtIncompatible // TODO private static <T> ListenableFuture<T> submitAndAddQueueListener( ListeningExecutorService executorService, Callable<T> task, final BlockingQueue<Future<T>> queue) { final ListenableFuture<T> future = executorService.submit(task); future.addListener( new Runnable() { @Override public void run() { queue.add(future); } }, directExecutor()); return future; }
@Override public ListenableFuture<?> spill(Iterator<Page> pageIterator) { requireNonNull(pageIterator, "pageIterator is null"); checkNoSpillInProgress(); spillInProgress = executor.submit(() -> writePages(pageIterator)); return spillInProgress; }
@Override public void run() { try { Future<?> future = executor.submit(incrementTask); assertTrue(future.isDone()); assertEquals(1, threadLocalCount.get().intValue()); } catch (Throwable t) { throwableFromOtherThread.set(t); } } });
@Test public void testSupervisorTaskDefaultSingleTestTaskHappyCase() throws Exception { // testTask should never timeout TestTask testTask = new TestTask(1, false); TimedSupervisorTask supervisorTask = new TimedSupervisorTask("test", scheduler, executor, 5, TimeUnit.SECONDS, EXP_BACK_OFF_BOUND, testTask); helperExecutor.submit(supervisorTask).get(); Assert.assertEquals(1, maxConcurrentTestTasks.get()); Assert.assertEquals(0, testTaskCounter.get()); Assert.assertEquals(1, testTaskStartCounter.get()); Assert.assertEquals(1, testTaskSuccessfulCounter.get()); Assert.assertEquals(0, testTaskInterruptedCounter.get()); }