@Override public ListenableFuture<V> reload(final K key, final V oldValue) throws Exception { ListenableFutureTask<V> task = ListenableFutureTask.create( new Callable<V>() { @Override public V call() throws Exception { return loader.reload(key, oldValue).get(); } }); executor.execute(task); return task; }
@Override public ListenableFuture<V> reload(final K key, final V oldValue) throws Exception { ListenableFutureTask<V> task = ListenableFutureTask.create( new Callable<V>() { @Override public V call() throws Exception { return loader.reload(key, oldValue).get(); } }); executor.execute(task); return task; }
@Override public ListenableFuture<V> reload(final K key, final V oldValue) throws Exception { ListenableFutureTask<V> task = ListenableFutureTask.create( new Callable<V>() { @Override public V call() throws Exception { return loader.reload(key, oldValue).get(); } }); executor.execute(task); return task; }
public ListenableFuture<?> acquireRequestPermit() { long delayNanos = backoff.getBackoffDelayNanos(); if (delayNanos == 0) { return Futures.immediateFuture(null); } ListenableFutureTask<Object> futureTask = ListenableFutureTask.create(() -> null); scheduledExecutor.schedule(futureTask, delayNanos, NANOSECONDS); return futureTask; }
public ListenableFuture<T> reload(final String key, T prev) { ListenableFutureTask<T> task = ListenableFutureTask.create(new Callable<T>() { public T call() { try { T t = load(key); if(t == null) { EVCacheMetricsFactory.increment(appName, null, null, "EVCacheInMemoryCache" + "-" + appName + "-Reload-NotFound"); return prev; } else { EVCacheMetricsFactory.increment(appName, null, null, "EVCacheInMemoryCache" + "-" + appName + "-Reload-Success"); } return t; } catch (EVCacheException e) { log.error("EVCacheException while reloading key -> {}", key, e); EVCacheMetricsFactory.increment(appName, null, null, "EVCacheInMemoryCache" + "-" + appName + "-Reload-Fail"); return prev; } } }); pool.execute(task); return task; } });
/** * Create a future task for the query * @param queryRequest incoming query request * @param executorService executor service to use for parallelizing query. This is passed to the QueryExecutor * @return Future task that can be scheduled for execution on an ExecutorService. Ideally, this future * should be executed on a different executor service than {@code e} to avoid deadlock. */ protected ListenableFutureTask<byte[]> createQueryFutureTask(@Nonnull ServerQueryRequest queryRequest, @Nonnull ExecutorService executorService) { return ListenableFutureTask.create(() -> processQueryAndSerialize(queryRequest, executorService)); }
@Override public ListenableFuture<CacheEntry> reload( final CacheKey key, final CacheEntry oldValue ) throws Exception { ListenableFutureTask<CacheEntry> task = ListenableFutureTask.create( new Callable<CacheEntry>() { public CacheEntry call() { return load( key ); } } ); //load via the refresh executor refreshExecutors.execute( task ); return task; }
@Override public ListenableFuture<String[]> reload( final String key, String[] oldValue ) throws Exception { ListenableFutureTask<String[]> task = ListenableFutureTask.create( new Callable<String[]>() { public String[] call() { return load( key ); } } ); refreshExecutors.execute( task ); return task; }
@Override protected <T> PrioritizedListenableFutureTask<T> newTaskFor(Callable<T> callable) { Preconditions.checkArgument( allowRegularTasks || callable instanceof PrioritizedCallable, "task does not implement PrioritizedCallable" ); return PrioritizedListenableFutureTask.create( ListenableFutureTask.create(callable), callable instanceof PrioritizedCallable ? ((PrioritizedCallable) callable).getPriority() : defaultPriority, config.isFifo() ? queuePosition.decrementAndGet() : 0 ); }
@Override protected <T> PrioritizedListenableFutureTask<T> newTaskFor(Runnable runnable, T value) { Preconditions.checkArgument( allowRegularTasks || runnable instanceof PrioritizedRunnable, "task does not implement PrioritizedRunnable" ); return PrioritizedListenableFutureTask.create( ListenableFutureTask.create(runnable, value), runnable instanceof PrioritizedRunnable ? ((PrioritizedRunnable) runnable).getPriority() : defaultPriority, config.isFifo() ? queuePosition.decrementAndGet() : 0 ); }
private ListenableFuture<?> resizeUpInternal(int delta) { // 1) Cancel the kills if any, to avoid killing the returned sessions. // Also sets the count for the async initialization. int oldVal; do { oldVal = deltaRemaining.get(); } while (!deltaRemaining.compareAndSet(oldVal, oldVal + delta)); int toStart = oldVal + delta; if (toStart <= 0) return createDummyFuture(); LOG.info("Resizing the pool; adding " + toStart + " sessions"); // 2) If we need to create some extra sessions, we'd do it just like startup does. int threadCount = Math.max(1, Math.min(toStart, HiveConf.getIntVar(initConf, ConfVars.HIVE_SERVER2_TEZ_SESSION_MAX_INIT_THREADS))); List<ListenableFutureTask<Boolean>> threadTasks = new ArrayList<>(threadCount); // This is an async method, so always launch threads, even for a single task. for (int i = 0; i < threadCount; ++i) { ListenableFutureTask<Boolean> task = ListenableFutureTask.create( new CreateSessionsRunnable(deltaRemaining)); new Thread(task, "Tez pool resize " + i).start(); threadTasks.add(task); } return Futures.allAsList(threadTasks); }
@Override public <V> ListenableScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) { ListenableFutureTask<V> task = ListenableFutureTask.create(new MDCPropagatingCallable<>(callable)); ScheduledFuture<?> scheduled = executorService.schedule(task, delay, unit); return new ListenableScheduledTask<>(task, scheduled); }
@Override public ListenableScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) { ListenableFutureTask<Void> task = ListenableFutureTask.create(new MDCPropagatingRunnable(command), null); ScheduledFuture<?> scheduled = executorService.schedule(task, delay, unit); return new ListenableScheduledTask<>(task, scheduled); }
@Override public ListenableFuture<SingularityUserPermissionsResponse> reload(String authHeaderVaule, SingularityUserPermissionsResponse oldVaule) { return ListenableFutureTask.create(() -> { try { return verifyUncached(authHeaderVaule); } catch (Throwable t) { LOG.warn("Unable to refresh user information", t); return oldVaule; } }); } });
@Override public ListenableFuture<V> reload(final K key, final V oldValue) throws Exception { ListenableFutureTask<V> task = ListenableFutureTask.create(new Callable<V>() { @Override public V call() throws Exception { return loader.reload(key, oldValue).get(); } }); executor.execute(task); return task; }
server.futureTaskQueue.add(ListenableFutureTask.create(lambda, null));
@Override public ListenableFuture<SetMultimap<Integer, FileReference>> reload(String key, SetMultimap<Integer, FileReference> oldValue) { ListenableFutureTask<SetMultimap<Integer, FileReference>> task = ListenableFutureTask.create(() -> loadFileReferencesForJob(key)); fileReferenceCacheReloader.submit(task); return task; }
/** * If refreshAfterWrite is enabled, this method is called after returning the old value. * The new value will be inserted into the cache when the load() operation completes. */ @Override public ListenableFuture<Optional<T>> reload(final String key, Optional<T> oldValue) { ListenableFutureTask<Optional<T>> task = ListenableFutureTask.create(() -> load(key)); executor.execute(task); return task; }
@Override public <T> ListenableFuture<T> submit(Callable<T> task) { ListenableFutureTask<T> ftask = ListenableFutureTask.create(task); execute(ftask); return ftask; }
@Override public ListenableScheduledFuture<?> schedule( Runnable command, long delay, TimeUnit unit) { ListenableFutureTask<Void> task = ListenableFutureTask.create(command, null); ScheduledFuture<?> scheduled = delegate.schedule(task, delay, unit); return new ListenableScheduledTask<Void>(task, scheduled); }