Services
Technology Web App Development Mobile App Development Windows App Development Database Development UI/UX Development Cloud Development SEO Digital Marketing Guest Posting Content Writing Artificial Intelligence Data Science ERP Development CRM Development CMS Development LMS Development Business Listing Blockchain Technology Startup Promotion AI Tools Integration
Products
Data Converter Cleaner TUC - Unit Converter Import Export Survey Manager Tweet Controller
Developer
Article Blog Forum Interview Beginner News Startup Quiz
Users
Career
Apply Job Internship
Pricing
Login Sign Up Get a Quote

forum

Home Forums What is the difference between Callable and Runnable in Java? – MindStick
Ask Question

1 Answers

Ashutosh Patel
Ashutosh Patel 19 Jul 2024
Report Abuse

Difference Between Callable and Runnable

Both Callable and Runnable are interfaces for describing tasks that can be executed simultaneously, usually by threads. Here is the main difference between Callable and Runnable.

Return Value

Runnable- The run() method of the Runnable interface does not return a result. A null method, means that it executes an event but returns no value.

Callable- The call() method of the Callable interface returns a result of the specified type (specified by the generic type parameter <V>). The call() method can throw checked exceptions, which must be handled or thrown or declared.

Handling Exception

Runnable- the run() method in Runnable cannot directly throw a noted exception. If it needs to throw a checked exception, it should be caught in the run() method and handled accordingly.

Callable- the call() method in Callable can throw a flagged exception. These exceptions must be caught in the call() method or declared in the throws clause of the method.

Usage with ExecutorService

Both the Runnable and the Callable can be passed to the ExecutorService for execution at the same time.

Example-

Runnable Syntax-

Runnable task = () -> {
   // Task implementation
};
executorService.submit(task);

Example-

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class RunnableExample {
   public static void main(String[] args) {
       ExecutorService executorService = Executors.newSingleThreadExecutor();
       // Runnable task
       Runnable task = () -> {
           try {
               Thread.sleep(2000);  // Simulate some task
               System.out.println("Runnable task completed");
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       };
       // Submit the task to the executor service
       executorService.submit(task);
       // Shutdown the executor service after task completion
       executorService.shutdown();
   }
}

Callable Syntax-

Callable<Integer> task = () -> {
   // Task implementation that returns a result
   return someResult;
};
Future<Integer> future = executorService.submit(task);

Example-

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class CallableExample {
   public static void main(String[] args) {
       ExecutorService executorService = Executors.newSingleThreadExecutor();
       // Callable task
       Callable<Integer> task = () -> {
           Thread.sleep(3000);  // Simulate some time-consuming task
           return 42;  // Return a result
       };
       // Submit the task to the executor service
       Future<Integer> future = executorService.submit(task);
       try {
           // Wait for the task to complete and get the result
           Integer result = future.get();
           System.out.println("Callable task completed, result: " + result);
       } catch (Exception e) {
           e.printStackTrace();
       }
       // Shutdown the executor service after task completion
       executorService.shutdown();
   }
}


Return Value Handling

Runnable- Since Runnable doesn’t return a value, you typically use a separate tool (such as a shared variable or some other synchronization technique) if you need to get a result or condition after a task is complete

Callable- When a Callable completes its execution, it returns a Future object that can be used to retrieve a statistic or to handle exceptions thrown during its execution.

Callable is an improvement over Runnable that lets functions return values ​​and throw checked exceptions, providing greater flexibility in concurrent programming scenarios

Also, Read: How to achieve thread-safety in Java?

advertising
Markdown for AI

A clean, structured version of this page for AI assistants and LLMs.

Open .md