Mark Knowledge of Java Thread (3): Future and Callable

My Future I Call the Shots

In sumary there are two ways to create a thread(new thread and implement runnable). Both of them are too simple to control its lifecycle and get result. Because the return type of run method is void. It should be improved. Luckily, we have future and callable implements to help us do that.

Future Is Not Always Good

People always have a perfect plan which is based on assumptive conditions. However the truth is not same. We expect a kind of power of control thus god give us future implement.

boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;     

En… frome these methods definition we can guess how they can be used. But we can get more information about its implementation class FutureTask

Give Me A Result

There is a big question is that thread can not return excution result. For this reason we can use Callable interface to finish this job with excute function.
Let’s see Callable interface first.

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

Happy Coding Time

This is a easy to create new thread. This thread will caculates count from 1 to 100 and main thread will print its result.

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class Test {

    /**
     * Simple way to let t1 stop before t2
     * 
     * @param args
     * @throws InterruptedException
     * @throws ExecutionException
     */
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        FutureTask<Integer> task = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("Start caculate.");
                int count = 0;
                for (int i = 1; i < 101; i++) {
                    count = count + i;
                }
                System.out.println("Finish caculate");
                return count;
            }
        });
        ExecutorService service = Executors.newSingleThreadExecutor();
        service.submit(task);
        System.out.println("Result is:" + task.get());
        service.shutdown();

    }
}