What is a callable and why should you use it e.g. compared to a runnable?
The difference between a callable and a runnable is that a callable can have a return type. Let’s look at a simple, constructed example in which we want to calculate the formula x * 2 – 42 for n numbers concurrently by starting a runnable for each of them.
The runnable code would look like e.g. like this
import java.util.Vector;
public class CalculationRunnable implements Runnable {
private int initialValue;
private Vector<Integer> results;
public CalculationRunnable(int initialValue, Vector<Integer> results) {
this.initialValue = initialValue;
this.results = results;
}
@Override
public void run() {
results.add(initialValue * 2 - 42);
}
}Because the runnable cannot return the result directly to the caller, a Vector object is passed. Why a Vector and not e.g. an ArrayList? The reason is that an ArrayList is not save to use for concurrent modification or is not “thread-safe” as some would call it. I do not like the term “thread-safe” because there are no specific requirements for when a class would be “thread-safe”.
You should only use methods and classes concurrently if you have written them for concurrent access or the API/SDK specifies that they are sequentially consistent or happens-before consistent (see Memory Models).
The Vector class is one of the implementations of the List interface that can be safely accessed concurrently.
A question, do you see any problems with the runnable code above?
After this small theoretical excourse, let’s look at how the example from before would look like as a callable.
import java.util.concurrent.Callable;
public class CalculationCallable implements Callable<Integer> {
private int initialValue;
public CalculationCallable(int initialValue) {
this.initialValue = initialValue;
}
@Override
public Integer call() throws Exception {
return initialValue * 2 - 42;
}
}As you can see in the code above, the call method can directly return the result without the need to put it into a shared data structure. Another advantage is that you can throw an exception.
Now we are only missing the comparison of how you use the two contracts to get the result for our concurrent calculations.
import java.util.ArrayList;
import java.util.Vector;
import java.util.concurrent.FutureTask;
public class CallableVSRunnable {
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<>();
for(int i = 1; i < 20; i++){
list.add(i);
}
// For storing the result we use a Vector (because ArrayList is not suited for concurrent access)
Vector<Integer> results = new Vector<>();
ArrayList<Thread> threads = new ArrayList<>();
for(int i : list){
Thread t = new Thread(new CalculationRunnable(i,results));
threads.add(t);
t.start();
}
// Wait until all threads have finished their task
for(Thread t : threads){
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("The results of the Runnables");
// Print the results
for(int i = 0; i < results.size(); i++){
System.out.println(results.get(i));
}
// And now with callables
ArrayList<FutureTask> tasks = new ArrayList<>();
for(int i : list){
CalculationCallable c = new CalculationCallable(i);
FutureTask task = new FutureTask<>(c);
tasks.add(task);
new Thread(task).start();
}
System.out.println("The results of the Callables");
try{
for(var task : tasks){
System.out.println(task.get());
}
} catch (Exception e){
e.printStackTrace();
}
}
}
The largest difference is that the callable implementation does not have to join the threads, this is done implicitly by the FutureTasks in which you have to wrap your Callable.
In summary, a Callable can be a good alternative to a Runnable when you want to return results and or would like to throw and catch exceptions from threads.
Finally, back to the question that I asked after showing the Runnable code. The answer is that there is a problem if you care about the correct order of the results in the Vector because they could theoretically be in any order because all threads try to insert their integer result without any order or schedule. A solution would be to use e.g. a Result class that would also include the x value as well as the result.