一、简介
很多同学在学多线程的时候不知道它后来能用在哪儿，这里我提供一个使用多线程的小思路。
现有一个微服务场景，用户想查看某个作者和该作者写的文章。那么他需要从用户服务和文章服务分别去调然后等待结果一起返回。假如用户服务需要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> {
V call() throws Exception;
}
interface Runnable {
public abstract void run();
}
区别：
1.Callable能接受一个泛型，然后在call方法中返回一个这个类型的值。而Runnable的run方法没有返回值
2.Callable的call方法可以抛出异常，而Runnable的run方法不会抛出异常。
再来看看Future接口：
public interface Future<V> {
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<Topic> 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<Author> findAuhtorTask = new FutureTask<>(()->{
System.out.println(Thread.currentThread().getName()+"正在处理...");
Author author = cacheDao.selectAuthorById(Integer.parseInt(authorId));
sleepThread(2000L);
return author;
});
FutureTask<List<Topic>> findTopicTask = new FutureTask<>(()->{
System.out.println(Thread.currentThread().getName()+"正在处理...");
List<Topic> 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;
}
```
