| /external/guava/src/com/google/common/util/concurrent/ |
| 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...] |
| 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...] |
| 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...] |
| 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();
|
| ValueFuture.java | 41 * Sets the value of this future. This method will return {@code true} if
42 * the value was successfully set, or {@code false} if the future has already
45 * @param newValue the value the future should hold.
54 * Sets the future to having failed with the given exception. This exception
57 * or {@code false} if the future has already been set or cancelled.
59 * @param t the exception the future should hold.
|
| ForwardingService.java | 22 import java.util.concurrent.Future;
35 /*@Override*/ public Future<State> start() {
43 /*@Override*/ public Future<State> stop() {
|
| /libcore/luni/src/main/java/java/util/concurrent/ |
| 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
|
| 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> {
|
| 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...] |
| AbstractExecutorService.java | 53 * @param value the default value for the returned future
55 * underlying runnable and which, as a <tt>Future</tt>, will yield
69 * underlying callable and which, as a <tt>Future</tt>, will yield
82 public Future<?> submit(Runnable task) {
93 public <T> Future<T> submit(Runnable task, T result) {
104 public <T> Future<T> submit(Callable<T> task) {
122 List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
145 Future<T> f = ecs.poll();
184 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 <tt>Future<?></tt> and
34 * Future<String> future
41 * displayText(future.get()); // use future
47 * The {@link FutureTask} class is an implementation of <tt>Future</tt> that
51 * FutureTask<String> future =
56 * executor.execute(future);
[all...] |
| RunnableScheduledFuture.java | 12 * <tt>Future</tt> and allows access to its results.
17 * @param <V> The result type returned by this Future's <tt>get</tt> method
|
| 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...] |
| /external/e2fsprogs/lib/uuid/ |
| configure.in | 2 dnl Not used now, for the future when uuid is separated out into its
|
| /external/kernel-headers/original/linux/mtd/ |
| compatmac.h | 7 kernels. Include guard just to make GCC ignore it in future inclusions
|
| /external/proguard/src/proguard/classfile/instruction/ |
| package.html | 8 application, it may very well be reorganised and extended in the future.
|
| /libcore/luni/src/test/java/tests/api/java/util/concurrent/ |
| AbstractExecutorServiceTest.java | 44 Future<?> future = e.submit(task); local
45 future.get();
55 Future<String> future = e.submit(new StringTask()); local
56 String result = future.get();
65 Future<?> future = e.submit(new NoOpRunnable()); local
66 future.get();
67 assertTrue(future.isDone())
75 Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING); local
[all...] |
| ExecutorCompletionServiceTest.java | 87 Future f = ecs.take();
95 * Take returns the same future object returned by submit
102 Future f1 = ecs.submit(c);
103 Future f2 = ecs.take();
122 Future f = ecs.poll();
143 Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
152 * returns and eventually runs Future returned by newTaskFor.
172 Future f1 = ecs.submit(c);
175 Future f2 = ecs.take();
185 * returns and eventually runs Future returned by newTaskFor
[all...] |
| /external/oprofile/daemon/ |
| opd_perfmon.h | 37 unsigned short ctx_reserved1; /* for future use */
40 unsigned long ctx_reserved2[11];/* for future use */
49 unsigned short reg_reserved1; /* for future use */
65 unsigned long reg_reserved2[3]; /* for future use */
71 unsigned short load_reserved1; /* for future use */
72 unsigned long load_reserved2[3]; /* for future use */
|
| /external/webkit/JavaScriptCore/parser/ |
| Keywords.table | 38 # reserved for future use
46 # these words are reserved for future use in the ECMA spec, but not in WinIE
|
| /build/core/combo/arch/arm/ |
| armv5te.mk | 12 # and a better solution should be found in the future.
|
| /external/kernel-headers/original/asm-arm/ |
| mman.h | 15 #define MCL_FUTURE 2 /* lock all future mappings */
|
| /ndk/sources/cpufeatures/ |
| README.TXT | 6 but it is DEPRECATED and will be removed in a future NDK release.
|
| /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...] |
