Callables and Futures Examples

Author: Rajeev Kumar Singh

java-callables-and-futures/src/FutureAndCallableExample.java

@@ -0,0 +1,27 @@
+import java.util.concurrent.*;
+
+/**
+ * Created by rajeevkumarsingh on 11/05/17.
+ */
+public class FutureAndCallableExample {
+    public static void main(String[] args) throws InterruptedException, ExecutionException {
+        ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+        Callable<String> callable = () -> {
+            // Perform some computation
+            Thread.sleep(2000);
+            return "Hello from Callable";
+        };
+
+        Future<String> future = executorService.submit(callable);
+        // This line executes immediately
+        System.out.println("Do something else while callable is getting executed");
+
+        System.out.println("Retrieve the result of the future");
+        // Future.get() blocks until the result is available
+        String result = future.get();
+        System.out.println(result);
+
+        executorService.shutdown();
+    }
+}

java-callables-and-futures/src/FutureCancelExample.java

@@ -0,0 +1,42 @@
+import java.util.concurrent.*;
+
+/**
+ * Created by rajeevkumarsingh on 10/05/17.
+ */
+public class FutureCancelExample {
+    public static void main(String[] args) throws InterruptedException, ExecutionException {
+        ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+        Callable<String> callable = () -> {
+            // Perform some computation
+            Thread.sleep(2000);
+            return "Hello from Callable";
+        };
+
+        long startTime = System.nanoTime();
+        Future<String> future = executorService.submit(callable);
+
+        while(!future.isDone()) {
+            System.out.println("Task is still not done...");
+            Thread.sleep(200);
+            double elapsedTimeInSec = (System.nanoTime() - startTime)/1000000000.0;
+
+            if(elapsedTimeInSec > 1) {
+                // cancel future if the elapsed time is more than one second
+                future.cancel(true);
+            }
+        }
+
+        // Check if future is cancelled before retrieving the result
+        if(!future.isCancelled()) {
+            System.out.println("Task completed! Retrieving the result");
+            // Future.get() blocks until the result is available
+            String result = future.get();
+            System.out.println(result);
+        } else {
+            System.out.println("Task was cancelled");
+        }
+        executorService.shutdown();
+    }
+
+}

java-callables-and-futures/src/FutureIsDoneExample.java

@@ -0,0 +1,27 @@
+import java.util.concurrent.*;
+
+/**
+ * Created by rajeevkumarsingh on 11/05/17.
+ */
+public class FutureIsDoneExample {
+    public static void main(String[] args) throws InterruptedException, ExecutionException {
+        ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+        Future<String> future = executorService.submit(() -> {
+            Thread.sleep(2000);
+            return "Hello from Callable";
+        });
+
+        while(!future.isDone()) {
+            System.out.println("Task is still not done...");
+            Thread.sleep(200);
+        }
+
+        System.out.println("Task completed! Retrieving the result");
+        String result = future.get();
+        System.out.println(result);
+
+        executorService.shutdown();
+    }
+
+}

java-callables-and-futures/src/InvokeAllExample.java

@@ -0,0 +1,36 @@
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.*;
+
+/**
+ * Created by rajeevkumarsingh on 10/05/17.
+ */
+public class InvokeAllExample {
+    public static void main(String[] args) throws InterruptedException, ExecutionException {
+        ExecutorService executorService = Executors.newFixedThreadPool(5);
+
+        Callable<String> task1 = () -> {
+            Thread.sleep(2000);
+            return "Result of Task1";
+        };
+
+        Callable<String> task2 = () -> {
+            Thread.sleep(1000);
+            return "Result of Task2";
+        };
+
+        Callable<String> task3 = () -> {
+            Thread.sleep(5000);
+            return "Result of Task3";
+        };
+
+        List<Callable<String>> taskList = Arrays.asList(task1, task2, task3);
+
+        List<Future<String>> futures = executorService.invokeAll(taskList);
+
+        for(Future<String> future: futures) {
+            // The result is printed only after all the futures are complete. (i.e. after 5 seconds)
+            System.out.println(future.get());
+        }
+    }
+}

java-callables-and-futures/src/InvokeAnyExample.java

@@ -0,0 +1,32 @@
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.*;
+
+/**
+ * Created by rajeevkumarsingh on 10/05/17.
+ */
+public class InvokeAnyExample {
+    public static void main(String[] args) throws InterruptedException, ExecutionException {
+        ExecutorService executorService = Executors.newFixedThreadPool(5);
+
+        Callable<String> task1 = () -> {
+            Thread.sleep(2000);
+            return "Result of Task1";
+        };
+
+        Callable<String> task2 = () -> {
+            Thread.sleep(1000);
+            return "Result of Task2";
+        };
+
+        Callable<String> task3 = () -> {
+            Thread.sleep(5000);
+            return "Result of Task3";
+        };
+
+        // Returns the result of the fastest callable. (task2 in this case)
+        String result = executorService.invokeAny(Arrays.asList(task1, task2, task3));
+
+        System.out.println(result);
+    }
+}