Java学习笔记之Callable和Future

Callable

一个接口，类似于Runnable,两者都是为那些其实力可能被另一个线程执行的类设计的。但是Runnable不能反回结果，并且不能抛出经过检查的异常。而Callable可以返回结果并且能抛出异常。

Future

一个接口，表示返回的结果。FutureTask是Future的一个实现。
示例：

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class CallableAndFutureTest {

    public static void main(String[] args){
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return new Random().nextInt(100);
            }
        };

        FutureTask<Integer> future = new FutureTask<Integer>(callable);
        new Thread(future).start();
        try{
            Thread.sleep(5000);
            System.out.println(future.get());
        }catch(InterruptedException e){
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

FutureTask实现了两个接口，Runnable和Future，所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
通过ExecutorService的submit方法执行Callable：

import java.util.Random;
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;
import java.util.concurrent.FutureTask;

public class CallableAndFutureTest {

    public static void main(String[] args){
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return new Random().nextInt(100);
            }
        };

        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        Future<Integer> future = threadPool.submit(callable);

        try{
            Thread.sleep(5000);
            System.out.println(future.get());
        }catch(InterruptedException e){
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

执行多个带返回值的任务，并取得返回值

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
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;
import java.util.concurrent.FutureTask;

public class CallableAndFutureTest {

    public static void main(String[] args){

        ExecutorService threadPool = Executors.newCachedThreadPool();
        List<Future<Integer>> list = new ArrayList<Future<Integer>>();
        for(int i=0;i<5;i++){
            Future<Integer> future = threadPool.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    return new Random().nextInt(1000);
                }
            });
            list.add(future);
        }

        try{
            Thread.sleep(5000);
            for(Future<Integer> future : list){
                System.out.println(future.get());
            }
        }catch(InterruptedException e){
            e.printStackTrace();
        }catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

本文参考自http://blog.csdn.net/ghsau/article/details/7451464