| /libcore/luni/src/main/java/java/util/concurrent/ |
| CompletionService.java | 34 * Submits a value-returning task for execution and returns a Future
39 * @return a Future representing pending completion of the task
44 Future<V> submit(Callable<V> task);
47 * Submits a Runnable task for execution and returns a Future
53 * @return a Future representing pending completion of the task,
60 Future<V> submit(Runnable task, V result);
63 * Retrieves and removes the Future representing the next
66 * @return the Future representing the next completed task
69 Future<V> take() throws InterruptedException;
72 * Retrieves and removes the Future representing the nex
[all...] |
| ScheduledFuture.java | 11 * Usually a scheduled future is the result of scheduling
16 * @param <V> The result type returned by this Future
18 public interface ScheduledFuture<V> extends Delayed, Future<V> {
|
| RunnableFuture.java | 10 * A {@link Future} that is {@link Runnable}. Successful execution of
11 * the {@code run} method causes completion of the {@code Future}
17 * @param <V> The result type returned by this Future's {@code get} method
19 public interface RunnableFuture<V> extends Runnable, Future<V> {
21 * Sets this Future to the result of its computation
|
| ExecutorCompletionService.java | 53 * List<Future<Result>> futures = new ArrayList<>(n);
69 * for (Future<Result> f : futures)
80 private final BlockingQueue<Future<V>> completionQueue;
87 BlockingQueue<Future<V>> completionQueue) {
92 private final Future<V> task;
93 private final BlockingQueue<Future<V>> completionQueue;
125 this.completionQueue = new LinkedBlockingQueue<Future<V>>();
142 BlockingQueue<Future<V>> completionQueue) {
151 public Future<V> submit(Callable<V> task) {
158 public Future<V> submit(Runnable task, V result)
[all...] |
| ExecutorService.java | 18 * methods that can produce a {@link Future} for tracking progress of
33 * Executor#execute(Runnable)} by creating and returning a {@link Future}
108 * result is retrieved via {@code Future.get()}.
176 * Future representing the pending results of the task. The
177 * Future's {@code get} method will return the task's result upon
192 * @return a Future representing pending completion of the task
197 <T> Future<T> submit(Callable<T> task);
200 * Submits a Runnable task for execution and returns a Future
201 * representing that task. The Future's {@code get} method will
207 * @return a Future representing pending completion of the tas
[all...] |
| /frameworks/base/libs/hwui/thread/ |
| Future.h | 28 class Future: public LightRefBase<Future<T> > {
30 Future(Condition::WakeUpType type = Condition::WAKE_UP_ONE): mBarrier(type), mResult() { }
31 ~Future() { }
34 * Returns the result of this future, blocking if
|
| Task.h | 23 #include "Future.h"
37 Task(): mFuture(new Future<T>()) { }
49 const sp<Future<T> >& future() const { function in class:android::uirenderer::Task
54 sp<Future<T> > mFuture;
|
| /packages/apps/Gallery2/gallerycommon/src/com/android/gallery3d/util/ |
| FutureListener.java | 20 public void onFutureDone(Future<T> future);
|
| Future.java | 19 // This Future differs from the java.util.concurrent.Future in these aspects:
23 // ignore that flag. Regardless whether the Future is cancelled, a return
25 // null if it finds the Future is cancelled.
29 public interface Future<T> {
|
| /external/guice/extensions/service/src/com/google/inject/service/ |
| Service.java | 20 import java.util.concurrent.Future;
34 * @return a future for the startup result, regardless of whether this call
35 * initiated startup. Calling {@link Future#get} will block until the
37 * the service fails to start, {@link Future#get} will throw an {@link
39 * {@link Future#get} returns immediately.
41 Future<State> start();
48 * @return a future for the shutdown result, regardless of whether this call
49 * initiated shutdown. Calling {@link Future#get} will block until the
52 * already finished stopping, {@link Future#get} returns immediately.
54 Future<State> stop()
[all...] |
| /external/testng/src/main/java/org/testng/internal/thread/ |
| FutureResultAdapter.java | 5 import java.util.concurrent.Future;
8 * A very reduced interface of <code>Future</code>.
13 Future<?> m_future;
15 public FutureResultAdapter(Future<?> future) {
16 m_future = future;
|
| /external/glide/library/src/main/java/com/bumptech/glide/request/ |
| FutureTarget.java | 5 import java.util.concurrent.Future;
9 * {@link java.util.concurrent.Future}. For example:
29 public interface FutureTarget<R> extends Future<R>, Target<R> {
|
| /external/libgdx/gdx/src/com/badlogic/gdx/utils/async/ |
| AsyncResult.java | 22 import java.util.concurrent.Future;
27 private final Future<T> future;
field in class:AsyncResult
29 AsyncResult (Future<T> future) {
30 this.future = future;
35 return future.isDone();
42 return future.get();
|
| /packages/apps/Camera2/src/com/android/camera/one/v2/initialization/ |
| DeferredManualAutoFocus.java | 21 import java.util.concurrent.Future;
30 private final Future<ManualAutoFocus> mManualAutoFocusFuture;
32 public DeferredManualAutoFocus(Future<ManualAutoFocus> manualAutoFocusFuture) {
43 // If the {@link Future} is not ready, do nothing.
|
| DeferredPictureTaker.java | 25 import java.util.concurrent.Future;
32 private final Future<PictureTaker> mPictureTakerFuture;
34 public DeferredPictureTaker(Future<PictureTaker> pictureTakerFuture) {
|
| /external/guava/guava/src/com/google/common/util/concurrent/ |
| AsyncFunction.java | 19 import java.util.concurrent.Future;
30 * Returns an output {@code Future} to use in place of the given {@code
31 * input}. The output {@code Future} need not be {@linkplain Future#isDone
35 * failing {@code Future}.
|
| ListenableFuture.java | 21 import java.util.concurrent.Future;
26 * A {@link Future} that accepts completion listeners. Each listener has an
27 * associated executor, and it is invoked using this executor once the future's
28 * computation is {@linkplain Future#isDone() complete}. If the computation has
39 * derived {@code Future}, as in {@link Futures#allAsList(Iterable)
45 * access to the {@code Future} result. (Users who want such access may prefer
50 * ListenableFuture<Result> future = service.query(name);
51 * future.addListener(new Runnable() {
65 * depends on how they currently create {@code Future} instances:
77 * <p>Occasionally, an API will return a plain {@code Future} and it will b
[all...] |
| ForwardingFuture.java | 23 import java.util.concurrent.Future;
28 * A {@link Future} which forwards all its method calls to another future.
30 * the backing future as desired per the <a
39 implements Future<V> {
44 @Override protected abstract Future<V> delegate();
78 * can pass in an already constructed {@link Future} as the delegate.
84 private final Future<V> delegate;
86 protected SimpleForwardingFuture(Future<V> delegate) {
91 protected final Future<V> delegate()
[all...] |
| JdkFutureAdapters.java | 26 import java.util.concurrent.Future;
32 * Future} instances. Note that, whenver possible, it is strongly preferred to
42 * Assigns a thread to the given {@link Future} to provide {@link
45 * <p><b>Warning:</b> If the input future does not already implement {@code
46 * ListenableFuture}, the returned future will emulate {@link
49 * until the future is {@linkplain Future#isDone() done}.
55 * Future} instances to be upgraded to {@code ListenableFuture} after the
59 Future<V> future) {
[all...] |
| ListeningExecutorService.java | 23 import java.util.concurrent.Future;
74 <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
95 <T> List<Future<T>> invokeAll(
|
| FutureCallback.java | 20 import java.util.concurrent.Future;
25 * A callback for accepting the results of a {@link java.util.concurrent.Future}
35 * Invoked with the result of the {@code Future} computation when it is
41 * Invoked when a {@code Future} computation fails or is canceled.
43 * <p>If the future's {@link Future#get() get} method throws an {@link
|
| FutureFallback.java | 22 import java.util.concurrent.Future;
25 * Provides a backup {@code Future} to replace an earlier failed {@code Future}.
26 * An implementation of this interface can be applied to an input {@code Future}
29 * @param <V> the result type of the provided backup {@code Future}
37 * Returns a {@code Future} to be used in place of the {@code Future} that
42 * @param t the exception that made the future fail. If the future's {@link
43 * Future#get() get} method throws an {@link ExecutionException}, then th
[all...] |
| /external/llvm/lib/Support/ |
| ThreadPool.cpp | 83 /// Wrap the Task in a packaged_task to return a future object.
85 auto Future = PackagedTask.get_future();
96 return Future.share();
138 // Get a Future with launch::deferred execution using std::async
139 auto Future = std::async(std::launch::deferred, std::move(Task)).share();
140 // Wrap the future so that both ThreadPool::wait() can operate and the
141 // returned future can be sync'ed on.
142 PackagedTaskTy PackagedTask([Future]() { Future.get(); });
144 auto Future = std::async(std::launch::deferred, std::move(Task), false).share()
[all...] |
| /external/guava/guava-bootstrap/src/java/util/concurrent/ |
| ExecutorService.java | 28 <T> Future<T> submit(Callable<T> task);
30 <T> Future<T> submit(Runnable task, T result);
32 Future<?> submit(Runnable task);
34 <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
37 <T> List<Future<T>> invokeAll(
|
| AbstractExecutorService.java | 17 public Future<?> submit(Runnable task) {
24 public <T> Future<T> submit(Runnable task, T result) {
31 public <T> Future<T> submit(Callable<T> task) {
46 List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
60 Future<T> f = ecs.poll();
99 for (Future<T> f : futures)
120 public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
124 List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size())
[all...] |
