## Uses of Interface
java.util.concurrent.Future

- Packages that use Future
  Package | Description
  --- | ---
  java.nio.channels | Defines channels, which represent connections to entities that are capable of performing I/O operations, such as files and sockets; defines selectors, for multiplexed, non-blocking I/O operations.
  java.util.concurrent | Utility classes commonly useful in concurrent programming.
  javax.swing | Provides a set of "lightweight" (all-Java language) components that, to the maximum degree possible, work the same on all platforms.
  javax.xml.ws | This package contains the core JAX-WS APIs.

- - ### Uses of Future in java.nio.channels

    Methods in java.nio.channels that return Future
    Modifier and Type | Method and Description
    --- | ---
    `abstract Future<AsynchronousSocketChannel>` | AsynchronousServerSocketChannel.`accept()` Accepts a connection.
    `abstract Future<Void>` | AsynchronousSocketChannel.`connect(SocketAddress remote)` Connects this channel.
    `Future<FileLock>` | AsynchronousFileChannel.`lock()` Acquires an exclusive lock on this channel's file.
    `abstract Future<FileLock>` | AsynchronousFileChannel.`lock(long position, long size, boolean shared)` Acquires a lock on the given region of this channel's file.
    `abstract Future<Integer>` | AsynchronousSocketChannel.`read(ByteBuffer dst)`
    `Future<Integer>` | AsynchronousByteChannel.`read(ByteBuffer dst)` Reads a sequence of bytes from this channel into the given buffer.
    `abstract Future<Integer>` | AsynchronousFileChannel.`read(ByteBuffer dst, long position)` Reads a sequence of bytes from this channel into the given buffer, starting at the given file position.
    `abstract Future<Integer>` | AsynchronousSocketChannel.`write(ByteBuffer src)`
    `Future<Integer>` | AsynchronousByteChannel.`write(ByteBuffer src)` Writes a sequence of bytes to this channel from the given buffer.
    `abstract Future<Integer>` | AsynchronousFileChannel.`write(ByteBuffer src, long position)` Writes a sequence of bytes to this channel from the given buffer, starting at the given file position.

  - ### Uses of Future in java.util.concurrent

    Subinterfaces of Future in java.util.concurrent
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `RunnableFuture<V>` A `Future` that is `Runnable`.
    `interface` | `RunnableScheduledFuture<V>` A `ScheduledFuture` that is `Runnable`.
    `interface` | `ScheduledFuture<V>` A delayed result-bearing action that can be cancelled.

    Classes in java.util.concurrent that implement Future
    Modifier and Type | Class and Description
    --- | ---
    `class` | `CompletableFuture<T>` A `Future` that may be explicitly completed (setting its value and status), and may be used as a `CompletionStage`, supporting dependent functions and actions that trigger upon its completion.
    `class` | `CountedCompleter<T>` A `ForkJoinTask` with a completion action performed when triggered and there are no remaining pending actions.
    `class` | `ForkJoinTask<V>` Abstract base class for tasks that run within a `ForkJoinPool`.
    `class` | `FutureTask<V>` A cancellable asynchronous computation.
    `class` | `RecursiveAction` A recursive resultless `ForkJoinTask`.
    `class` | `RecursiveTask<V>` A recursive result-bearing `ForkJoinTask`.

    Methods in java.util.concurrent that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<V>` | CompletionService.`poll()` Retrieves and removes the Future representing the next completed task, or `null` if none are present.
    `Future<V>` | ExecutorCompletionService.`poll()`
    `Future<V>` | CompletionService.`poll(long timeout, TimeUnit unit)` Retrieves and removes the Future representing the next completed task, waiting if necessary up to the specified wait time if none are yet present.
    `Future<V>` | ExecutorCompletionService.`poll(long timeout, TimeUnit unit)`
    `<T> Future<T>` | ScheduledThreadPoolExecutor.`submit(Callable<T> task)`
    `<T> Future<T>` | AbstractExecutorService.`submit(Callable<T> task)`
    `<T> Future<T>` | ExecutorService.`submit(Callable<T> task)` Submits a value-returning task for execution and returns a Future representing the pending results of the task.
    `Future<V>` | CompletionService.`submit(Callable<V> task)` Submits a value-returning task for execution and returns a Future representing the pending results of the task.
    `Future<V>` | ExecutorCompletionService.`submit(Callable<V> task)`
    `Future<?>` | ScheduledThreadPoolExecutor.`submit(Runnable task)`
    `Future<?>` | AbstractExecutorService.`submit(Runnable task)`
    `Future<?>` | ExecutorService.`submit(Runnable task)` Submits a Runnable task for execution and returns a Future representing that task.
    `<T> Future<T>` | ScheduledThreadPoolExecutor.`submit(Runnable task, T result)`
    `<T> Future<T>` | AbstractExecutorService.`submit(Runnable task, T result)`
    `<T> Future<T>` | ExecutorService.`submit(Runnable task, T result)` Submits a Runnable task for execution and returns a Future representing that task.
    `Future<V>` | CompletionService.`submit(Runnable task, V result)` Submits a Runnable task for execution and returns a Future representing that task.
    `Future<V>` | ExecutorCompletionService.`submit(Runnable task, V result)`
    `Future<V>` | CompletionService.`take()` Retrieves and removes the Future representing the next completed task, waiting if none are yet present.
    `Future<V>` | ExecutorCompletionService.`take()`

    Methods in java.util.concurrent that return types with arguments of type Future
    Modifier and Type | Method and Description
    --- | ---
    `<T> List<Future<T>>` | AbstractExecutorService.`invokeAll(Collection<? extends Callable<T>> tasks)`
    `<T> List<Future<T>>` | ExecutorService.`invokeAll(Collection<? extends Callable<T>> tasks)` Executes the given tasks, returning a list of Futures holding their status and results when all complete.
    `<T> List<Future<T>>` | ForkJoinPool.`invokeAll(Collection<? extends Callable<T>> tasks)`
    `<T> List<Future<T>>` | AbstractExecutorService.`invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)`
    `<T> List<Future<T>>` | ExecutorService.`invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)` Executes the given tasks, returning a list of Futures holding their status and results when all complete or the timeout expires, whichever happens first.

    Constructor parameters in java.util.concurrent with type arguments of type Future
    Constructor and Description
    `ExecutorCompletionService(Executor executor, BlockingQueue<Future<V>> completionQueue)` Creates an ExecutorCompletionService using the supplied executor for base task execution and the supplied queue as its completion queue.

  - ### Uses of Future in javax.swing

    Classes in javax.swing that implement Future
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SwingWorker<T,V>` An abstract class to perform lengthy GUI-interaction tasks in a background thread.

  - ### Uses of Future in javax.xml.ws

    Subinterfaces of Future in javax.xml.ws
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `Response<T>` The `Response` interface provides methods used to obtain the payload and context of a message sent in response to an operation invocation.

    Methods in javax.xml.ws that return Future
    Modifier and Type | Method and Description
    --- | ---
    `Future<?>` | Dispatch.`invokeAsync(T msg, AsyncHandler<T> handler)` Invoke a service operation asynchronously.

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2017, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.