| /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
54 * = new ArrayList<Future<Result>>(n);
70 * for (Future<Result> f : futures)
81 private final BlockingQueue<Future<V>> completionQueue;
92 private final Future<V> task;
123 this.completionQueue = new LinkedBlockingQueue<Future<V>>();
140 BlockingQueue<Future<V>> completionQueue) {
149 public Future<V> submit(Callable<V> task) {
156 public Future<V> submit(Runnable task, V result) {
163 public Future<V> take() throws InterruptedException
[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
191 * @return a Future representing pending completion of the task
196 <T> Future<T> submit(Callable<T> task);
199 * Submits a Runnable task for execution and returns a Future
200 * representing that task. The Future's {@code get} method will
205 * @return a Future representing pending completion of the tas
[all...] |
| Future.java | 10 * A {@code Future} represents the result of an asynchronous
19 * If you would like to use a {@code Future} for the sake
21 * declare types of the form {@code Future<?>} and
34 * Future<String> future
41 * displayText(future.get()); // use future
46 * The {@link FutureTask} class is an implementation of {@code Future} that
50 * FutureTask<String> future =
55 * executor.execute(future);}</pre
[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>()) { }
50 const sp<Future<T> >& future() const { function in class:android::uirenderer::Task
55 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/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> {
|
| /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...] |
| AbstractListeningExecutorService.java | 28 import java.util.concurrent.Future;
85 public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
90 List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
98 for (Future<T> f : futures) {
109 for (Future<T> f : futures) {
117 public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout,
123 List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
134 Iterator<Future<T>> it = futures.iterator()
[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/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...] |
| /external/clang/test/SemaCXX/ |
| decltype.cpp | 20 struct Future {
21 explicit Future(T v);
36 Future<int> f1(42);
37 f1.call([](int){ return Future<float>(0); });
|
| /packages/apps/Gallery2/src/com/android/gallery3d/ui/ |
| BitmapLoader.java | 22 import com.android.gallery3d.util.Future;
45 private Future<Bitmap> mTask;
49 public void onFutureDone(Future<Bitmap> future) {
52 mBitmap = future.get();
60 if (future.isCancelled() && mBitmap == null) {
106 abstract protected Future<Bitmap> submitBitmapTask(FutureListener<Bitmap> l);
|
