线程--Callable和Future

+ 创建线程：
- 通过Thread直接创建
- 通过Runnable接口创建 
- 通过Callable和Future接口创建。
＊ Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务。 
＋ Callable和Runnable的区别如下：  
- Callable定义的方法是call，而Runnable定义的方法是run。
- Callable的call方法可以有返回值，而Runnable的run方法不能有返回值。
- Callable的call方法可抛出异常，而Runnable的run方法不能抛出异常。 
- Callable接口有范型限制，Callable接口里的泛型形参类型与call方法的反回类型相同，而且Callable接口是函数式接口，因此可以用Lambda表达式创建Callable对象。
+ Future表示异步计算的结果，它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。Future的cancel方法取消任务的执行，有一个布尔参数，参数为true表示立即中断任务的执行，参数为false表示允许正在运行的任务运行完成。Future的get方法等待计算完成，获取计算结果。

    - Future只是一个接口，所以是无法直接用来创建对象使用的。FutureTask是Future接口的一个实现类，它实现了RunnableFuture接口继承的Runnable接口和Future接口，因此既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。


代码示例：

 

 

 

 

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


public class CallableAndFuture {


    /**
     * 自定义一个任务类(求前n项和)，实现Callable接口
     */
    public static class SumNumbers implements Callable<Integer> {


        private int val = 0;


        public SumNumbers(int val){
            this.val = val;
        }


        public Integer call() throws Exception {
            int sum = 0;
            for (int i = 0; i <= val; ++i) {
                if (Integer.MAX_VALUE - sum < i) {
                    throw new RuntimeException("overflow: " + sum + "+" + i + ">" + Integer.MAX_VALUE);
                }
                sum += i;
                TimeUnit.MICROSECONDS.sleep(1);
            }
            return sum;
        }
    }


    public static void testInvokeAny() {
        List<SumNumbers> tasks = new ArrayList<SumNumbers>();
        tasks.add(new SumNumbers(100));
        tasks.add(new SumNumbers(200));
        tasks.add(new SumNumbers(Integer.MAX_VALUE));
        tasks.add(new SumNumbers(Integer.MAX_VALUE));
        tasks.add(new SumNumbers(5000));


        // 创建一个执行任务的服务
        ExecutorService es = Executors.newFixedThreadPool(tasks.size());
        System.out.println("invoke any tasks!!!");
        Integer result = 0;
        try {
            result = es.invokeAny(tasks, 1, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        // Integer result = es.invokeAny(tasks);
        System.out.println(String.format("result = %d \n", result));
        // 停止任务执行服务
        es.shutdownNow();
    }


    public static void testInvokeAll() {
        List<SumNumbers> tasks = new ArrayList<SumNumbers>();
        tasks.add(new SumNumbers(100));
        tasks.add(new SumNumbers(200));
        tasks.add(new SumNumbers(Integer.MAX_VALUE));
        tasks.add(new SumNumbers(Integer.MAX_VALUE));
        tasks.add(new SumNumbers(5000));


        // 创建一个执行任务的服务
        ExecutorService es = Executors.newFixedThreadPool(tasks.size());
        try {
            System.out.println("invoke any tasks!!!");
            // Integer result = es.invokeAny(tasks, 5, TimeUnit.SECONDS);
            Integer result = es.invokeAny(tasks);
            System.out.println(String.format("result = %d \n", result));


            TimeUnit.SECONDS.sleep(1);
            System.out.println("invoke all tasks!!!");
            List<Future<Integer>> results = es.invokeAll(tasks, 1000, TimeUnit.MILLISECONDS);
            // TimeUnit.SECONDS.sleep(10);
            System.out.println("Begin to get results...");
            long t1 = System.currentTimeMillis();
            for (int i = 0; i < results.size(); ++i) {
                // 线程可能在submit和get之间的运行中出现异常，但是Future<T>会记录结果和异常
                // 获取结果方法1: 防止task运行总出现异常了呢 这里要处理一下
                try {
                    System.out.println("result " + i + ", isDone=" + results.get(i).isDone() + ", isCanceled= "
                                       + results.get(i).isCancelled()); // 一般都是true
                    System.out.println("result " + i + " : " + results.get(i).get());
                    TimeUnit.MILLISECONDS.sleep(10);
                } catch (Throwable e) {
                    System.err.println("skipp failed tasks : \n" + e.toString() + "\n\n");
                }
                // 获取结果方法2:通过isCancelled来判断是否正常结束
                if (!results.get(i).isCancelled()) {
                    System.out.println("Result completed normally  " + i + " : " + results.get(i).get());
                }
            }
            long t2 = System.currentTimeMillis();
            System.out.println("Time-consuming=" + (t2 - t1) + " ms");
        } catch (Exception e) {
            System.out.println("error");
            System.out.println(e.toString());
        }
        // 停止任务执行服务
        es.shutdownNow();
    }


    /**
     * FutureTask封装了结果
     */
    public static void testFutureTask() {
        try {
            FutureTask<Integer> task = new FutureTask<Integer>(new SumNumbers(100));
            // 创建一个执行任务的服务
            ExecutorService es = Executors.newFixedThreadPool(1);
            es.submit(task);


            // 正确的获取结果
            System.out.println(task.get());


            // 下面后去result的方法是不对的
            Future<?> result = es.submit(task);
            if (result.get() == null) {
                System.out.println("the result is in the task object!");
            }
            es.shutdown(); // must shutdown ExecutorService
        } catch (Exception e) {
            e.printStackTrace();
        }


    }


    public static void main(String[] args) {
        // testFutureTask();
        testInvokeAll();
        testInvokeAny();
    }
}

 

注意：
ExecutorService.submit或者invokeAll的Task，如果超时没有返回结果的线程，那么ExecutorService会cancel这些线程（stop 这些线程），不会让这些线程继续运行下去。