03.Java基础（线程池和Callable<T>）

在以往的工作中，创建线程通常我们关注的都是Thread或者Runnable为主，其实忽略了另外一个比较有用的创建线程的方式，就是Callable接口,下边是Callable配合线程池实现异步任务

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 CallableDemo {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService pool = Executors.newCachedThreadPool();
        Future<Object> future = pool.submit(new MyCallable());
        //通过get方法获取执行结果，该方法会阻塞直到任务返回结果
        Object obj = future.get();
        System.out.println(obj.toString());
    }

}

class MyCallable implements Callable<Object>{

    @Override
    public Object call() throws Exception {
        System.out.println("执行callable3");
        return "right";
    }
    
}

在Java中，创建线程一般有两种方式，一种是继承Thread类，一种是实现Runnable接口。然而，这两种方式的缺点是在线程任务执行结束后，无法获取执行结果。我们一般只能采用共享变量或共享存储区以及线程通信的方式实现获得任务结果的目的。
不过，Java中，也提供了使用Callable和Future来实现获取任务结果的操作。Callable用来执行任务，产生结果，而Future用来获得结果。

可以看到，与Runnable接口不同之处在于，call方法带有泛型返回值V。

我们通过简单的例子来体会使用Callable和Future来获取任务结果的用法。
假设我们现在有一个任务，要计算出1-10000之间的所有数字的和，为了提升计算速度，我们使用两个线程，第一个线程计算1-5000的和，另外有一个线程计算5001-10000之间的数字的和。为了更好的展示效果，让每个线程在计算过程中休眠5s。

示例程序来自网友：

    import java.util.ArrayList;  
    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 TestMain{  
        public static void main(String[] args) throws InterruptedException, ExecutionException {  
            ExecutorService executor = Executors.newCachedThreadPool();  
            ArrayList<Future<Integer>> resultList = new ArrayList<>();  
              
            //创建并提交任务1  
            AddNumberTask task1 = new AddNumberTask(1, 5000);  
            Future<Integer> future1 = executor.submit(task1);  
            resultList.add(future1);  
              
            //创建并提交任务2  
            AddNumberTask task2 = new AddNumberTask(5001, 10000);  
            Future<Integer> future2 = executor.submit(task2);  
            resultList.add(future2);  
              
            executor.shutdown();  
              
            int total = 0;  
              
            for(Future<Integer> future : resultList){  
                while(true){  
                    if(future.isDone() && !future.isCancelled()){  
                        int sum = future.get();  
                        total += sum;  
                        break;  
                    }  
                    else{  
                        Thread.sleep(100);  
                    }  
                }  
            }  
              
            System.out.println("total sum is " + total);  
        }  
      
    }  
      
    class AddNumberTask implements Callable<Integer>{  
        private int start;  
        private int end;  
          
        public AddNumberTask(int start, int end) {  
            // TODO Auto-generated constructor stub  
            this.start = start;  
            this.end = end;  
        }  
          
        @Override  
        public Integer call() throws Exception {  
            // TODO Auto-generated method stub  
            int totalSum = 0;  
              
            for(int i = start; i <= end; i++){  
                totalSum += i;  
            }  
              
            Thread.sleep(5000);  
              
            return totalSum;  
        }  
          
    }