Difference between Callable and Runnable in Java - Thread Interview question

Difference between Callable and Runnable interface in Java is one of the interesting questions from my list of Top 15 Java multi-threading questions, and it’s also very popular in various Java Interviews. The Callable interface is newer than Runnable interface and added on Java 5 release along with other major changes e.g. Generics, Enum, Static imports and variable argument method. Though both Callable and Runnable interface are designed to represent a task, which can be executed by any thread, there is some significant difference between them. In my opinion, the major difference between Callable and Runnable interface is that Callable can return the result of an operation performed inside call() method, which was one of the limitations with Runnable interface.
Another significant difference between Runnable and Callable interface is the ability to throw checked exception. The Callable interface can throw checked exception because it's call method throws Exception. 

By the way, sometimes this question is also asked as follow-up question of another classic difference between Runnable and Thread in Java. Commonly FutureTask is used along with Callable to get the result of asynchronous computation task performed in call() method.

Callable vs Runnable interface in Java

As I explained major differences between a Callable and Runnable interface in the last section. Sometimes this question is also asked as the difference between call() and run() method in Java. All the points discussed here is equally related to that question as well. Let's see them in point format for better understanding :

1) The Runnable interface is older than Callable, there from JDK 1.0, while Callable is added on Java 5.0.

2) Runnable interface has run() method to define task while Callable interface uses call() method for task definition.

3) run() method does not return any value, it's return type is void while call method returns value. The Callable interface is a generic parameterized interface and Type of value is provided when an instance of Callable implementation is created.

4) Another difference on run and call method is that run method can not throw checked exception while call method can throw checked exception in Java.

Here is a nice summary of all the differences between Callable and Runnable in Java:

Runnable vs Callable in Java

That's all on Difference between Callable and Runnable interface in Java or difference between call() and run() method. Both are a very useful interface from core Java and a good understanding of where to use Runnable and Callable is a must for any good Java developer. In next article, we will see an example of Callable interface along with FutureTask to learn How to use Callable interface in Java.

Other Java multi-threading questions for practice
Difference between start() and run() method of Thread class.
How to solve producer consumer problem in Java using wait and notify
Why to wait and notify method are declared in Object class
Difference between CyclicBarrier and CountDownLatch in Java
Why to wait and notify method required to called from synchronized context

Further Learning
Multithreading and Parallel Computing in Java
Applying Concurrency and Multi-threading to Common Java Patterns
Java Concurrency in Practice - The Book
Java Concurrency in Practice Bundle by Heinz Kabutz


  1. What is the real use of Callable interface, I have never use it in production yet. to me Runnable seems to work always? I know that Callable can return value, throw Exception but I have to yet to found a convincing case to use it on production code. Can anyone who has some hands on experience suggest good examples of Callable in Java?

    1. Well the fact that method call() can return whatever type you want makes easy to trigger the execution of a method into a separate thread and return when the execution is over.
      For example, I have been using this pattern lately to run Groovy scripts into a Java application to handle specific behaviours for some of our customers. With running the custom script (written by third parties) into separate threads, I can better control their execution (i.e. stop them if they exceed a maximum duration). Combined with the java ScriptEngine framework, all I had to do is provide with an interface that Groovy scripts had to implement, and a little code to stick all this together.

      But honestly, the above article is a little poor as it doesn't provide much more information that the API javadoc.

    2. Sir Mr Laurent Thomas i am new to this callable interface if you could share your experience with these interface then it would be better for us