Java Callable Future Example

Published on August 3, 2022


Java Callable Future Example

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Java Callable and Future are used a lot in multithreaded programming. In last few posts, we learned a lot about java threads but sometimes we wish that a thread could return some value that we can use. Java 5 introduced java.util.concurrent.Callable interface in concurrency package that is similar to Runnable interface but it can return any Object and able to throw Exception.

Java Callable

java Callable, java Future, java callable example, java executorservice callable Java Callable interface use Generic to define the return type of Object. Executors class provide useful methods to execute Java Callable in a thread pool. Since callable tasks run in parallel, we have to wait for the returned Object.

Java Future

Java Callable tasks return java.util.concurrent.Future object. Using Java Future object, we can find out the status of the Callable task and get the returned Object. It provides get() method that can wait for the Callable to finish and then return the result. Java Future provides cancel() method to cancel the associated Callable task. There is an overloaded version of get() method where we can specify the time to wait for the result, it’s useful to avoid current thread getting blocked for longer time. There are isDone() and isCancelled() methods to find out the current status of associated Callable task. Here is a simple example of Java Callable task that returns the name of thread executing the task after one second. We are using Executor framework to execute 100 tasks in parallel and use Java Future to get the result of the submitted tasks.

package com.journaldev.threads;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MyCallable implements Callable<String> {

    public String call() throws Exception {
        //return the thread name executing this callable task
        return Thread.currentThread().getName();
    public static void main(String args[]){
        //Get ExecutorService from Executors utility class, thread pool size is 10
        ExecutorService executor = Executors.newFixedThreadPool(10);
        //create a list to hold the Future object associated with Callable
        List<Future<String>> list = new ArrayList<Future<String>>();
        //Create MyCallable instance
        Callable<String> callable = new MyCallable();
        for(int i=0; i< 100; i++){
            //submit Callable tasks to be executed by thread pool
            Future<String> future = executor.submit(callable);
            //add Future to the list, we can get return value using Future
        for(Future<String> fut : list){
            try {
                //print the return value of Future, notice the output delay in console
                // because Future.get() waits for task to get completed
                System.out.println(new Date()+ "::"+fut.get());
            } catch (InterruptedException | ExecutionException e) {
        //shut down the executor service now


Once we execute the above program, you will notice the delay in output because java Future get() method waits for the java callable task to complete. Also notice that there are only 10 threads executing these tasks. Here is snippet of the output of above program.

Mon Dec 31 20:40:15 PST 2012::pool-1-thread-1
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-3
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-4
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-5
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-6
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-7
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-8
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-9
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-10
Mon Dec 31 20:40:16 PST 2012::pool-1-thread-2

Tip: What if we want to override some of the methods of Java Future interface, for example overriding get() method to timeout after some default time rather than waiting indefinitely, in this case Java FutureTask class comes handy that is the base implementation of Future interface. Check out Java FutureTask Example to learn more about this class.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Learn more about our products

About the authors
Default avatar


Still looking for an answer?

Ask a questionSearch for more help

Was this helpful?
DigitalOcean Employee
DigitalOcean Employee badge
April 1, 2019

hi, I have a query does Future creates new thread. Thanks!

- Nisha

    DigitalOcean Employee
    DigitalOcean Employee badge
    March 9, 2019

    Thanks a lot,it really helped me :)


      DigitalOcean Employee
      DigitalOcean Employee badge
      September 28, 2018

      Place Callable callable = new MyCallable(); into “fori” It will be right

      - Alex

        DigitalOcean Employee
        DigitalOcean Employee badge
        August 21, 2018

        hi, thanks for nice explanation of threadpool. I have some question. please clear my understanding. 1.Here the thread pool size is 10. So it creates 10 threads right? that means whatever the size we give to executor creates that many threads and all threads execute same method call() . 2.Here in output why we have output for thred-2 again as per method once it prints method finish then why its executing thread again ?

        - urvi

          DigitalOcean Employee
          DigitalOcean Employee badge
          February 15, 2018

          Thanks for the example.

          - Aakshi

            DigitalOcean Employee
            DigitalOcean Employee badge
            October 13, 2017

            Thanks for this tutorial! I did have to make one modification. I changed (A) to (B) where: (A) Future future = executor.submit(callable); (B) Future future = executor.submit(new MyCallable());

            - Shane

              DigitalOcean Employee
              DigitalOcean Employee badge
              July 10, 2017

              Thanks for sharing simple and understandable example. I have a question, it may be very silly but i want to clarify it with you. In above example we will always get output as : pool-1-thread-(Number), where pool-1 is common, here my question is since we have created pool of size 5. Output should also change accordingly like pool-1, pool-2 etc.

              - Utpal

                DigitalOcean Employee
                DigitalOcean Employee badge
                October 24, 2016

                Hi Pankaj, This is very useful. Thanks fro sharing your knowledge with us.

                - Veranga Sooriyabandara

                  DigitalOcean Employee
                  DigitalOcean Employee badge
                  December 7, 2015

                  Thanks ! , useful…!

                  - shgy

                    DigitalOcean Employee
                    DigitalOcean Employee badge
                    November 18, 2015

                    Super note. Thanks for sharing the stuff

                    - Chaitanya

                      Try DigitalOcean for free

                      Click below to sign up and get $200 of credit to try our products over 60 days!

                      Sign up

                      Join the Tech Talk
                      Success! Thank you! Please check your email for further details.

                      Please complete your information!

                      Featured on Community

                      Get our biweekly newsletter

                      Sign up for Infrastructure as a Newsletter.

                      Hollie's Hub for Good

                      Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

                      Become a contributor

                      Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

                      Welcome to the developer cloud

                      DigitalOcean makes it simple to launch in the cloud and scale up as you grow — whether you're running one virtual machine or ten thousand.

                      Learn more
                      DigitalOcean Cloud Control Panel