????????哈喽，大家早上好，距离上次发文章，已经过去3个月了，说来惭愧，我是打cs时，被对面枪枪爆头，瞬时进入贤者状态，在思考自己为什么要手欠开游戏。寻思时想起自己还有个csdn号，所以马上来更新篇文章，哈哈哈哈。
????????闲话不多说，我们现在来进入正题，对于业务涉及要查询大数据单表，多表时，我们有很多方法能解决查询较慢问题，如：正确运用索引，优化查询sql、分表等等，但在本文中，我们会将焦点放在如何用多线程去处理这个问题。
? ? ? ? 我们要如何去处理呢？带着这个疑问，我们再看看如何创建多线程，常规的三种：继承Thread类、实现Runnable接口、实现Callable接口。毫无疑问，我们需要采用最后一种方法，因为这个是带返回值的。
? ? ? ? 很好，方法找到了，那么实现的思路应该要怎么样呢？
????????针对大数据单表，我们的思路应该是将一次查询分为若干的小查询，分别用多线程去调用，最后把各个查询的返回值整合，组装成总的返回结果。虽然访问数据库的次数多了，但是比单次查询大数据所用的时间快很多，如下图所示：
?
? ? ? ? 针对业务要查询多个表，然后汇总查询出来的表做业务相关的处理（表间相互独立），这种情况的话，用多线程也是挺合适的.
????????因为如果单线程的情况下，需要等表a查询完毕（100ms），才会去查询b(100ms)，算上组装、传输耗时（20ms），那么需要耗时：100+100+20=220ms，如下图所示：
? ? ? ? 当是在多线程的情况下，我们可以同时分别查询表a（100ms）,表b（100ms），算上组装、传输耗时（20ms），那么需要耗时：100+20=120ms，如下图所示：
? ? ? ? 到这里，大家应该都能看出多线程解决查询大数据单表、多表是怎么处理吧，那么我们下面直接上代码，看看怎么用代码实现的。
? ? ? ? 先上项目目录结构图，这是个springboot架构的项目，数据库用的是mysql，跟数据库交互部分用的是mybatis-plus。
? ? ? ? 我们先来创建调用接口吧，代码如下：
package com.tony.mulitithread.controller;
import com.tony.mulitithread.domain.FileInfo;
import com.tony.mulitithread.domain.ResultBean;
import com.tony.mulitithread.service.FileService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.List;
@RestController
@RequestMapping("/file")
public class FileController {
@Resource
private FileService fileService;
@GetMapping
public ResultBean<List<FileInfo>> queryList() {
return new ResultBean<>(fileService.queryFiles());
}
@GetMapping("/mulitit")
public ResultBean<List<FileInfo>> queryFilesByMulitiThread() {
return new ResultBean<>(fileService.queryFilesByMulitiThread());
}
@GetMapping("/more")
public ResultBean<List<FileInfo>> queryMore() {
return new ResultBean<>(fileService.queryMore());
}
@GetMapping("/more/mulitit")
public ResultBean<List<FileInfo>> queryMoreMulitit() {
return new ResultBean<>(fileService.queryMoreMulitit());
}
}
?????????前2个接口是针对大数据单表单线程、多线程查询耗时情况，后2个接口是针对多表情况，单线程、多线程查询耗时情况。
? ? ? ? 查询单表多线程：
/**
* 以多线程形式查询单表
*/
public List<FileInfo> queryFilesByMulitiThread() {
//表总数
Integer total = fileMapper.selectCount(new QueryWrapper<>());
//创建一个线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
List<Callable<List<FileInfo>>> taskList = new ArrayList<>();
List<FileInfo> result = new ArrayList<>();
//根据表总数确定查询次数
int selectNum = total / 100000;
if (total % 100000 != 0) {
selectNum += 1;
}
for (int i = 0; i <= selectNum; i++) {
//用多线程查询,先创建callable
int start = 100000 * i;
int num = 100000;
taskList.add(new FileCallable(start, num));
}
long startTime = 0;
long endTime = 0;
try {
startTime = System.currentTimeMillis();
List<Future<List<FileInfo>>> futureList = threadPoolExecutor.invokeAll(taskList);
if (ObjectUtil.isNotEmpty(futureList)) {
for (Future<List<FileInfo>> data : futureList) {
result.addAll(data.get());
}
}
endTime = System.currentTimeMillis();
} catch (Exception e) {
e.printStackTrace();
} finally {
//关闭线程池
threadPoolExecutor.shutdown();
}
System.out.println("=====查询数据总条数：" + result.size());
System.out.println("=====多线程查询耗时：" + (endTime - startTime));
return result;
}? ? ? ? 这就是service层的运用，因为单表涉及到物理分表的原因，我们需要定义一个类去实现Callable，代码如下：
package com.tony.mulitithread.threads;
import com.tony.mulitithread.domain.FileInfo;
import com.tony.mulitithread.mapper.FileMapper;
import com.tony.mulitithread.utils.SpringContextUtil;
import org.springframework.context.ApplicationContext;
import java.util.List;
import java.util.concurrent.Callable;
public class FileCallable implements Callable<List<FileInfo>> {
private int start;
private int num;
private List<FileInfo> data;
private static ApplicationContext applicationContext = SpringContextUtil.getApplicationContext();
public FileCallable(int start, int num) {
this.start = start;
this.num = num;
}
@Override
public List<FileInfo> call() throws Exception {
//获取bean
FileMapper fileMapper = applicationContext.getBean(FileMapper.class);
List<FileInfo> fileInfos = fileMapper.queryList(start, num);
this.data = fileInfos;
return data;
}
}
? ? ? ? 因为在这种情况下，我们不能通过注解直接获取FileMapper的bean，因此我们要写一个类去实现接口ApplicationContextAware，去获取上下文applicationContext，帮助我们去获得FileMapper的bean，代码如下：
package com.tony.mulitithread.utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public class SpringContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtil.applicationContext = applicationContext;
}
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
@SuppressWarnings("unchecked")
public static <T> T getBean(Class<?> clz) {
return (T) applicationContext.getBean(clz);
}
}
? ? ? ? 好，现在让我们来测试下接口吧，因为我开启了sql打印功能，所以时间会慢很多。
????????测试接口 ：localhost:8080/file
? ? ? ? 测试3次，取其平均值
????????测试接口 ：localhost:8080/file/mulitit （多线程）
? ? ? ? 测试3次，取其平均值
? ? ? ? 这里我们可以清楚发现，在多线程的情况下查询大数据单表，是比单线程快的。?
? ? ? ? 查询多表多线程：
/**
* 以多线程形式查询多表
*/
public List<FileInfo> queryMoreMulitit() {
//创建线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
List<FileInfo> result = new ArrayList<>();
try {
long startTime = System.currentTimeMillis();
Future<List<FileInfo2>> file2Future = threadPoolExecutor.submit(() -> file2Mapper.selectList(new QueryWrapper<>()));
Future<List<FileInfo3>> file3Future = threadPoolExecutor.submit(() -> file3Mapper.selectList(new QueryWrapper<>()));
List<FileInfo2> fileInfo2s = file2Future.get();
List<FileInfo3> fileInfo3s = file3Future.get();
long endTime = System.currentTimeMillis();
fileInfo2s.forEach(p -> {
FileInfo temp = new FileInfo();
BeanUtil.copyProperties(p, temp);
result.add(temp);
});
fileInfo3s.forEach(p -> {
FileInfo temp = new FileInfo();
BeanUtil.copyProperties(p, temp);
result.add(temp);
});
System.out.println("表t_file_2条数：" + fileInfo2s.size());
System.out.println("表t_file_3条数：" + fileInfo3s.size());
System.out.println("合并展示条数：" + result.size());
System.out.println("=====多线程所有查询所耗时间：" + (endTime - startTime));
} catch (Exception e) {
e.printStackTrace();
}
return result;
}????????测试接口 ：localhost:8080/file/more
? ? ? ? 测试3次，取其平均值
????????测试接口 ：localhost:8080/file/more/mulitit （多线程）
? ? ? ? 测试3次，取其平均值
? ? ? ? ?这里也可以清楚看到，也是多线程的情况查询比较快的
? ? ? ? 结论：多线程永远滴神，但是如果你要用，要注意下线程安全方面的问题，而且我测试的数据都是30w左右，不大，其他情况你们可以测试下，对了完整的代码我放在了github上，你们可以自己下载试试。好了，溜了，我要去继续cs了。