Multithreading is the notion of handling program actions that do not take place in the program’s main Thread, which is handled by many different Threads. This concept will make the processing of the program faster. We have many ways to implement multithreading in Java, but in this tutorial, I only introduce to you all about Callable and Future in Java with the ability to return result after processing and can throw an exception if in during processing, there is an error.
OK, let’s get started …
First, I will create a new project for example:
Callable is an interface that uses Java Generic to define the object that will be returned after processing the task. Here, I will take the example of the sum of two numbers, but instead of handling this sum in the main thread of the program, I will use Callable to process in another thread.
Its Callable object will have the following content:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.huongdanjava.callablefuture; import java.util.concurrent.Callable; public class Calculator implements Callable<Integer> { private int a; private int b; public Calculator(int a, int b) { this.a = a; this.b = b; } public Integer call() throws Exception { return a + b; } } |
To execute Callable’s task, we must submit it to a Thread Pool using the submit() method of the Executor Framework.
Now, I will create the main class for the above example with the following content:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
package com.huongdanjava.callablefuture; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Example { public static void main(String[] args) { // Create thread pool using Executor Framework ExecutorService executor = Executors.newFixedThreadPool(10); for (int i = 0; i < 10; i++) { // Create new Calculator object Calculator c = new Calculator(i, i + 1); executor.submit(c); } executor.shutdown(); } } |
With the code above, we just stop at the level submiting a Callable object to the Thread Pool to handle the task. How to get the results after processing is completed? If you notice, you will see that the return object of the submit() method is a Future object. Using this Future object, we can manage the status of the Callable task and retrieve returned object of the Callable object.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package com.huongdanjava.callablefuture; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class Example { public static void main(String[] args) { // Create thread pool using Executor Framework ExecutorService executor = Executors.newFixedThreadPool(10); for (int i = 0; i < 10; i++) { // Create new Calculator object Calculator c = new Calculator(i, i + 1); Future f = executor.submit(c); } executor.shutdown(); } } |
To get the result returned object with the Future object, we will use its get() method to wait until the Callable operation completes and returns the result.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
package com.huongdanjava.callablefuture; import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class Example { public static void main(String[] args) throws ExecutionException, InterruptedException { // Create thread pool using Executor Framework ExecutorService executor = Executors.newFixedThreadPool(10); List<Future<Integer>> list = new ArrayList<Future<Integer>>(); for (int i = 0; i < 10; i++) { // Create new Calculator object Calculator c = new Calculator(i, i + 1); list.add(executor.submit(c)); } for (Future f : list) { System.out.println(f.get()); } executor.shutdown(); } } |
Result:
The get() method is synchronous, so it will block our program every time we wait for the result of Callable. To limit the risk of blocking the program too long, we can use this get() method with a timeout like below:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
package com.huongdanjava.callablefuture; import java.util.ArrayList; import java.util.List; import java.util.concurrent.*; public class Example { public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException { // Create thread pool using Executor Framework ExecutorService executor = Executors.newFixedThreadPool(10); List<Future<Integer>> list = new ArrayList<Future<Integer>>(); for (int i = 0; i < 10; i++) { // Create new Calculator object Calculator c = new Calculator(i, i + 1); list.add(executor.submit(c)); } for (Future f : list) { System.out.println(f.get(3, TimeUnit.SECONDS)); } executor.shutdown(); } } |
In addition, we can use the isDone(), isCancelled() method of the Future object to find out the current status of the Callable object that it is currently monitoring.
UshaK
“I will create a new thread using Callable to process.” This statement is not correct. You get thread from a thread pool using Executors and submit Callable task to be executed by that thread.
Khanh Nguyen
Thanks you, corrected the sentence.