FuturesA.java Simple example of using Futures.

FuturesA.java

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class FuturesA {

    public static void run() throws Exception {
        ExecutorService executor = new ThreadPoolExecutor(4, 4, 1, TimeUnit.MINUTES, new LinkedBlockingQueue<Runnable>());

        Future<String> f1 = executor.submit(new CallToRemoteServiceA());
        Future<String> f2 = executor.submit(new CallToRemoteServiceB());

        System.out.println(f1.get() + " - " + f2.get());
    }

    public static void main(String args[]) {
        try {
            run();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static final class CallToRemoteServiceA implements Callable<String> {
        @Override
        public String call() throws Exception {
            // simulate fetching data from remote service
            Thread.sleep(100);
            return "responseA";
        }
    }

    private static final class CallToRemoteServiceB implements Callable<String> {
        @Override
        public String call() throws Exception {
            // simulate fetching data from remote service
            Thread.sleep(40);
            return "responseB";
        }
    }
    
}

Will you consider add those after the io?

    executor.shutdown();
    executor.awaitTermination(100, TimeUnit.MILLISECONDS);

The expected output is that System.out.println(f1.get() + " - " + f2.get());
will take 140 ms to return?

No, both future will start in parallel. It will take less than (100+40) ms.

expression in sysout will take approximately 100ms to get evaluated

It will take 140ms approximately if there is single core, otherwise it will do 100ms

@limxtop1989 It will not take 140ms on single core because both threads can sleep in parallel, it will not wait for one thread's sleep to finish before executing another thread.