Callable方式创建线程，并使用线程池异步执行任务

      线程的创建方式比较熟悉的是通过集成Runnable接口或者集成Thread类来实现，但是这两种方法都在线程执行完成后无法获取到执行结果，如果想异步执行某个任务并且执行完成之后需要知道他执行的结果的话可以使用Callable方式实现。

      例如创建一个ReadBookService类除了实现本身的业务接口外还实现Callable接口，Callable接口的异步执行方法是call()方法，这样就可以在call方法内部调用业务本身的方法来达到异步执行的效果。

public class ReadBookService implements IReadBookService, Callable<String> {

    private Map<String, Object> param;

    public ReadBookService(Map<String, Object> param) {
        this.param = param;
    }

    @Override
    public String readBook(String bookName) {
        System.out.println(bookName);
        return bookName;
    }

    @Override
    public String call() throws Exception {
        return readBook(Thread.currentThread().getName() + "正在阅读" + param.get("bookName").toString());
    }
}

在异步执行中获取最终的执行结果需要借助FutrueTask来完成，下面代码借助线程池来执行该方法

public class App {

    private static final ExecutorService executorService = new ThreadPoolExecutor(3, 6,
            5000L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(20), new ThreadPoolExecutor.DiscardPolicy());

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Map<String, Object> param = new HashMap<>();
            param.put("bookName", "java" + i);
            FutureTask<String> futureTask = new FutureTask<>(new ReadBookService(param));
            executorService.submit(futureTask);
        }
    }
}

Callable接口实现类作为FutureTask的构造函数参数，同时把futureTask提交到executorService 中进行执行，代码到此仍然没有获取到异步执行的结果，如果需要获取到异步执行结果则需要通过futrueTask该对象，每一个线程都会对应一个futrueTask对象，就是通过futureTask该对象来获取执执行结果。

futureTask获取执行结果有:

1.futureTask.get()  该方法会一直阻塞直到运行完成结果返回；

2.futureTask.get(long timeout,TimeUnit unit）该方法在阻塞timeout时间后如果还未拿到结果则直接退出，防止线程阻塞时间过长。

如果需要获取结果则代码修改如下：

public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Map<String, Object> param = new HashMap<>();
            param.put("bookName", "java" + i);
            FutureTask<String> futureTask = new FutureTask<>(new ReadBookService(param));
            executorService.submit(futureTask);
            try {
                System.out.println("获取到结果值:"+futureTask.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

但是如上代码仍然存在问题，由于futureTask.get() 是阻塞式等待结果返回，在每一次提交到线程池执行后就调用get()方法阻塞获取结果，这样获取方式仍然不是异步获取。进一步对代码进行修改，把每一个线程对应futrueTask对象暂存到一个list或者map中，这样在所有任务均已提交执行后再去获取执行结果，如下代码所示：

public class App {

    private static final ExecutorService executorService = new ThreadPoolExecutor(3, 6,
            5000L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(20), new ThreadPoolExecutor.DiscardPolicy());

    private static List<FutureTask<String>> futureTaskList = new ArrayList<>();

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Map<String, Object> param = new HashMap<>();
            param.put("bookName", "java" + i);
            FutureTask<String> futureTask = new FutureTask<>(new ReadBookService(param));
            executorService.submit(futureTask);
            futureTaskList.add(futureTask);
        }

        for (FutureTask<String> futureTask : futureTaskList) {
            try {
                System.out.println(futureTask.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        
    }
}

这样任务的执行是并行执行，获取结果是阻塞式获取，则服务运行的最长时间是最后执行完结果返回的时间，如果其中一个线程执行完成需要花费10s，但是其余99个线程在1s就已经执行完成，则获取主线程阻塞的时间是10s，如果更巧的是那个花费10s的线程刚好放在list的第一位，则其余99个线程的结果也需要在第10s之后才能够获取到，显然这存在一定的优化空间。