What's the difference between Future and FutureTask in Java?

What's the difference between Future and FutureTask in Java?

In Java, both Future and FutureTask are related to asynchronous computation and represent the result of a potentially long-running operation. However, they serve slightly different purposes:

  1. Future Interface:

    • Future is an interface introduced in Java 5 (java.util.concurrent.Future).
    • It represents the result of an asynchronous computation that may not be available yet.
    • Future provides methods for checking whether the computation is complete (isDone()), waiting for the computation to complete (get()), and canceling the computation (cancel()).
    • It is typically used when you want to submit a task for asynchronous execution (e.g., using an ExecutorService) and obtain a handle to the result of that task for later retrieval or status checking.

  2. FutureTask Class:

    • FutureTask is a concrete class that implements the Future interface and also implements the Runnable interface, making it suitable for use with ExecutorService.
    • It is a way to create and manage a future result that can be executed asynchronously by submitting it to an ExecutorService.
    • You can create a FutureTask by passing a Callable or Runnable to its constructor.
    • It allows you to wrap existing synchronous code and execute it asynchronously.
    • FutureTask provides more control and customization options compared to using Future alone, such as the ability to override its done() method to perform actions when the computation is complete.

Here's a basic example demonstrating the use of Future and FutureTask:

import java.util.concurrent.*; public class FutureVsFutureTask { public static void main(String[] args) throws InterruptedException, ExecutionException { // Using Future ExecutorService executor = Executors.newSingleThreadExecutor(); Future<String> future = executor.submit(() -> { Thread.sleep(2000); return "Hello from Future"; }); // Using FutureTask FutureTask<String> futureTask = new FutureTask<>(() -> { Thread.sleep(2000); return "Hello from FutureTask"; }); Thread thread = new Thread(futureTask); thread.start(); // Getting results String result1 = future.get(); String result2 = futureTask.get(); System.out.println(result1); System.out.println(result2); executor.shutdown(); } }

In this example, both Future and FutureTask are used to perform a computation asynchronously, and their results are obtained using the get() method. FutureTask allows you to create the computation using a Callable and run it in a separate thread, while Future represents the result of a submitted task.

In summary, Future is an interface for representing the result of an asynchronous computation, while FutureTask is a concrete class that implements the Future interface and can be used to create and manage such computations, making it suitable for use with an ExecutorService.

More Tags

gridsearchcv go-templates stm32f1 jsf windows-subsystem-for-linux windows cgi scaling venn-diagram transformation

More Java Questions

More Stoichiometry Calculators

More Bio laboratory Calculators

More General chemistry Calculators

More Housing Building Calculators