Springboot配合FutureTask/Callable实现并行处理

一、简介

很多同学在学多线程的时候不知道它后来能用在哪儿，这里我提供一个使用多线程的小思路。

现有一个微服务场景，用户想查看某个作者和该作者写的文章。那么他需要从用户服务和文章服务分别去调然后等待结果一起返回。假如用户服务需要2秒返回结果，文章服务需要3秒返回结果，加起来就是5秒，如果业务在复杂一点可能还会调别的服务，例如订单服务、商品服务。。。那么如此我们的调用时间是累加的。系统的等待时间随着业务复杂不断地提高。

换一种方式，如果用户服务与文章服务并行 ，那么水桶原理大家都知道吧，也就是说最后系统的等待时间是其中一个微服务调用时间最长的，在我的例子中也就是3秒。就算后期业务复杂读提高，也只会等待时间最长的那个服务调用，提升性能和系统吞吐量。

JUC为我们提供了 FutureTask/Callable 实现异步调用并获取返回结果。

FutureTask/Callable 都是JUC(java.util.concurrent)包中的类和接口。

深度了解FutureTask请看这篇：

转载：https://baijiahao.baidu.com/s?id=1630613195863161441&wfr=spider&for=pc

Callable和Runnable的区别

public interface Callable {

V call() throws Exception;

}

interface Runnable {

public abstract void run();

}

区别：

1.Callable能接受一个泛型，然后在call方法中返回一个这个类型的值。而Runnable的run方法没有返回值

2.Callable的call方法可以抛出异常，而Runnable的run方法不会抛出异常。

再来看看Future接口：

public interface Future {

boolean cancel(boolean var1);

　boolean isCancelled();

   boolean isDone();

　V get() throws InterruptedException, ExecutionException;

　V get(long var1, TimeUnit var3) throws InterruptedException, ExecutionException, TimeoutException;

} 

get方法用于获取执行任务的返回值。

它的重载方法第二个参数用于指定阻塞时间，如果阻塞时间到了就会抛出异常。

通过例子演示：

首先创建一个线程池，因为每次都创建销毁线程势必造成很大的资源浪费。

```

@Configuration

public class ThreadPoolConfig {

    /**

    * 默认线程池

    *

    * @return Executor

    */

    @Bean

    public ThreadPoolTaskExecutor defaultThreadPool() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

        //核心线程数目

        executor.setCorePoolSize(16);

        //指定最大线程数

        executor.setMaxPoolSize(64);

        //队列中最大的数目

        executor.setQueueCapacity(16);

        //线程名称前缀

        executor.setThreadNamePrefix("defaultThreadPool_");

        //rejection-policy：当pool已经达到max size的时候，如何处理新任务

        //CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行

        //对拒绝task的处理策略

        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        //线程空闲后的最大存活时间

        executor.setKeepAliveSeconds(60);

        //加载

        executor.initialize();

        return executor;

    }

}

```

串行方式

```

/**

    * 串行接口测试

    * @param authorId

    * @return

    */

    @Override

    public TopicAndAuthor getAuthorAndTopicByAuthorId(String authorId) throws InterruptedException {

        Long timeStart = System.currentTimeMillis();

        Author author = cacheDao.selectAuthorById(Integer.parseInt(authorId));

        sleepThread(2000L);

        List topics = cacheDao.selectTopicByAuthor(authorId);

        sleepThread(3000L);

        TopicAndAuthor topicAndAuthor = new TopicAndAuthor(author,topics);

        Long timeEnd = System.currentTimeMillis();

        System.out.println("串行接口耗时"+(timeEnd-timeStart));

        return topicAndAuthor;

    }

```

并行方式

```

@Override

    public TopicAndAuthor getAuthorAndTopicByAuthorId(String authorId) throws InterruptedException, ExecutionException {

        Long timeStart = System.currentTimeMillis();

        FutureTask findAuhtorTask = new FutureTask<>(()->{

            System.out.println(Thread.currentThread().getName()+"正在处理...");

            Author author = cacheDao.selectAuthorById(Integer.parseInt(authorId));

            sleepThread(2000L);

            return author;

        });

        FutureTask> findTopicTask = new FutureTask<>(()->{

            System.out.println(Thread.currentThread().getName()+"正在处理...");

            List topics = cacheDao.selectTopicByAuthor(authorId);

            sleepThread(3000L);

            return topics;

        });

        executor.execute(findAuhtorTask);

        executor.execute(findTopicTask);

        TopicAndAuthor topicAndAuthor = new TopicAndAuthor(findAuhtorTask.get(),findTopicTask.get());

        Long timeEnd = System.currentTimeMillis();

        System.out.println("并行接口一共耗时"+(timeEnd-timeStart));

        return topicAndAuthor;

    }

```