| /libcore/luni/src/main/java/java/util/concurrent/ |
| CompletionService.java | 35 * Submits a value-returning task for execution and returns a Future
40 * @return a Future representing pending completion of the task
45 Future<V> submit(Callable<V> task);
48 * Submits a Runnable task for execution and returns a Future
54 * @return a Future representing pending completion of the task,
61 Future<V> submit(Runnable task, V result);
64 * Retrieves and removes the Future representing the next
67 * @return the Future representing the next completed task
70 Future<V> take() throws InterruptedException;
74 * 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 <tt>run</tt> method causes completion of the <tt>Future</tt>
17 * @param <V> The result type returned by this Future's <tt>get</tt> 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 | 15 * methods that can produce a {@link Future} for tracking progress of
30 * Executor#execute} by creating and returning a {@link Future} that
107 * result is retrieved via {@code Future.get()}.
176 * Future representing the pending results of the task. The
177 * Future's <tt>get</tt> 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 <tt>get</tt> method will
205 * @return a Future representing pending completion of the tas
[all...] |
| AbstractExecutorService.java | 49 * @param value the default value for the returned future
51 * underlying runnable and which, as a <tt>Future</tt>, will yield
65 * underlying callable and which, as a <tt>Future</tt>, will yield
78 public Future<?> submit(Runnable task) {
89 public <T> Future<T> submit(Runnable task, T result) {
100 public <T> Future<T> submit(Callable<T> task) {
118 List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
141 Future<T> f = ecs.poll();
178 for (Future<T> f : futures
[all...] |
| Future.java | 10 * A <tt>Future</tt> represents the result of an asynchronous
19 * If you would like to use a <tt>Future</tt> 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 <tt>Future</tt> that
50 * FutureTask<String> future =
55 * executor.execute(future);}</pre
[all...] |
| /packages/apps/Gallery2/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> {
|
| JobLimiter.java | 41 private static class JobWrapper<T> implements Future<T>, Job<T> {
44 private Future<T> mDelegate;
53 public synchronized void setFuture(Future<T> future) {
55 mDelegate = future;
136 public synchronized <T> Future<T> submit(Job<T> job, FutureListener<T> listener) {
137 JobWrapper<T> future = new JobWrapper<T>(Utils.checkNotNull(job), listener); local
138 mJobs.addLast(future);
140 return future;
143 public <T> Future<T> submit(Job<T> job)
[all...] |
| /external/guava/src/com/google/common/base/ |
| Service.java | 20 import java.util.concurrent.Future;
54 * @return a future for the startup result, regardless of whether this call
55 * initiated startup. Calling {@link Future#get} will block until the
58 * the service fails to start, {@link Future#get} will throw an {@link
60 * State#FAILED}. If it has already finished starting, {@link Future#get}
61 * returns immediately. Cancelling the returned future is unsupported and
64 Future<State> start();
95 * @return a future for the shutdown result, regardless of whether this call
96 * initiated shutdown. Calling {@link Future#get} will block until the
99 * already finished stopping, {@link Future#get} returns immediately
[all...] |
| /external/guava/src/com/google/common/util/concurrent/ |
| ListenableFuture.java | 20 import java.util.concurrent.Future;
24 * <p>This interface defines a future that has listeners attached to it, which
26 * executor, and is invoked using this executor once the {@code Future}'s
27 * computation is {@linkplain Future#isDone() complete}. The listener will be
32 * final ListenableFuture<?> future = myService.async(myRequest);
33 * future.addListener(new Runnable() {
37 * System.out.println("Result: " + future.get());
48 public interface ListenableFuture<V> extends Future<V> {
53 * to the executor} for execution when the {@code Future}'s computation is
54 * {@linkplain Future#isDone() complete}
[all...] |
| ForwardingService.java | 22 import java.util.concurrent.Future;
35 /*@Override*/ public Future<State> start() {
43 /*@Override*/ public Future<State> stop() {
|
| UninterruptibleFuture.java | 20 import java.util.concurrent.Future;
25 * A {@code Future} whose {@code get} calls cannot be interrupted. If a thread
29 * Futures#makeUninterruptible(Future)}.
34 public interface UninterruptibleFuture<V> extends Future<V> {
|
| ForwardingFuture.java | 22 import java.util.concurrent.Future;
27 * A {@link Future} which forwards all its method calls to another future.
37 implements Future<V> {
39 @Override protected abstract Future<V> delegate();
|
| CheckedFuture.java | 21 import java.util.concurrent.Future;
26 * A {@code CheckedFuture} is an extension of {@link Future} that includes
28 * allows listeners to be attached to the future. This makes it easier to
29 * create a future that executes logic which can throw an exception.
32 * {@code Future#get()}: {@link CancellationException},
37 * listeners to be added. This allows the future to be used as a normal
38 * {@link Future} or as an asynchronous callback mechanism as needed. This
40 * future will guarantee execution of all listeners when the task completes.
49 * Exception checking version of {@link Future#get()} that will translate
53 * @return the result of executing the future
[all...] |
| AbstractExecutionThreadService.java | 23 import java.util.concurrent.Future;
126 /*@Override*/ public final Future<State> start() {
142 /*@Override*/ public final Future<State> stop() {
|
| AbstractIdleService.java | 24 import java.util.concurrent.Future;
101 /*@Override*/ public final Future<State> start() {
117 /*@Override*/ public final Future<State> stop() {
|
| Futures.java | 25 import java.util.concurrent.Future;
35 * Static utility methods pertaining to the {@link Future} interface.
46 * Returns an uninterruptible view of a {@code Future}. If a thread is
47 * interrupted during an attempt to {@code get()} from the returned future, it
52 final Future<V> future) {
53 checkNotNull(future);
54 if (future instanceof UninterruptibleFuture) {
55 return (UninterruptibleFuture<V>) future;
59 return future.cancel(mayInterruptIfRunning)
[all...] |
| /frameworks/base/core/java/android/accounts/ |
| AccountManagerFuture.java | 18 import java.util.concurrent.Future;
34 * If you would like to use a <tt>Future</tt> for the sake
36 * declare types of the form <tt>Future<?></tt> and
83 * Accessor for the future result the {@link AccountManagerFuture} represents. This
99 * Accessor for the future result the {@link AccountManagerFuture} represents. This
|
| /packages/apps/Contacts/src/com/android/contacts/vcard/ |
| ProcessorBase.java | 19 import java.util.concurrent.Future;
31 * {@link #get()} and {@link #get(long, TimeUnit)}, which are form {@link Future}, aren't
51 * @see Future#cancel(boolean)
|
| /packages/apps/Gallery2/src/com/android/gallery3d/data/ |
| MediaSet.java | 20 import com.android.gallery3d.util.Future;
223 * Requests sync on this MediaSet. It returns a Future object that can be used by the caller
225 * defined in this class and can be obtained by Future.get().
229 * The default implementation here returns a Future stub that does nothing and returns
232 public Future<Integer> requestSync(SyncListener listener) {
237 private static final Future<Integer> FUTURE_STUB = new Future<Integer>() {
260 protected Future<Integer> requestSyncOnMultipleSets(MediaSet[] sets, SyncListener listener) {
264 private class MultiSetSyncFuture implements Future<Integer>, SyncListener {
268 private final Future<Integer> mFutures[]
[all...] |
| ComboAlbumSet.java | 21 import com.android.gallery3d.util.Future;
83 public Future<Integer> requestSync(SyncListener listener) {
|
| /sdk/emulator/qtools/ |
| trace_reader_base.h | 172 struct Future {
173 Future *next;
177 inline Future *AllocFuture();
178 inline void FreeFuture(Future *future);
179 inline void InsertFuture(Future *future);
183 Future futures_[kMaxNumBasicBlocks];
184 Future *head_;
185 Future *free_
[all...] |
| /libcore/support/src/test/java/tests/support/ |
| Support_Exec.java | 33 import java.util.concurrent.Future;
87 Future<String> errFuture = executorService.submit(
89 Future<String> outFuture = executorService.submit(
127 Future<String> errFuture =
129 Future<String> outFuture =
|
