Disclosure: This article may contain affiliate links. When you purchase, we may earn a commission.

Difference between Callable and Runnable in Java - Thread Interview question

The difference between the 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 the Runnable interface and was 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 interfaces 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 the Callable and Runnable interface is that Callable can return the result of an operation performed inside the call() method, which was one of the limitations of the Runnable interface.
Another significant difference between the Runnable and Callable interfaces is the ability to throw checked exceptions. The Callable interface can throw checked exceptions because its call method throws Exceptions. 

By the way, sometimes this question is also asked as a 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 the 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 are 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 which is 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, its return type is void while the call method returns a value. The Callable interface is a generic parameterized interface and a Type of value is provided when an instance of Callable implementation is created.

4) Another difference in the run and call method is that the run method can not throw checked exceptions while the call method can throw checked exceptions 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 the 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 the next article, we will see an example of the Callable interface along with FutureTask to learn How to use the 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


  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


Feel free to comment, ask questions if you have any doubt.