Java使用多线程做批处理（查询大量数据）
Java使用多线程做批处理（查询大量数据）
前言背景
什么是进程：
“进程”是操作系统的概念，一个独立运行的程序，就是一个“进程”。
什么是线程：
“线程”是由“进程创建”的，一个进程可以创建任意多的线程，每个线程都包含一些代码。线程中的代码会同主进程或者其他线程“同时运行”。什么是多进程：
同一时间段，同时运行多个程序。
什么是多线程：
一个程序同时启动多个线程，也就是多个代码块同时运行。从而提高程序的运行效率。二、并发和并行
什么是并发
多个线程同时访问同一资源
例：你正在吃饭，有人来敲门，你放下饭碗去开门，回来接着吃饭。什么是并行
多个线程同时开始运行
例：你正在吃饭，来电话啦，你边吃饭边打电话
Java使用多线程的条件
批处理（批量上传，批量导出，批量更新）
查询大量数据
本文以查询为例，展示一下线程池的使用。
本文使用的多线程框架是Executor
Executor 框架是 Java5 之后引进的，在 Java5 之后，通过Executor来启动线程比使用 Thread 的start方法更好
扫描二维码关注公众号，回复： 14766847 查看本文章
详情可以参考博客
https://else.wiki/post/JavaThreadPool
操作流程
- 查询出表的数据总量。
- 数据的切分，根据本机CPU的核数配置合适数量的线程处理数，根据数据总量为不同的线程分配不同的查询数据量分段，即不同的线程查询不同分段的数据。
- 将各个查询数据的线程提交至线程池，这里使用的线程是带有返回结果的异步线程。（这样能把所有查询结果合并，才能进行下一步的操作。拿不到处理后的数据还怎么做下一步操作呢，所以一点要选择带有返回结果的线程）
为了例子足够简单，这里的数据总量直接写死，不去查询对应的数据库，我们的关注点放在，如何使用多线程以及多线程查询的结果合并，查询的表如下图，有1条数据，分成4个线程，每一个线程查询1条数据返回，最后把多个线程查询的数据合并
controller层
@Resource
private IBlogService blogService;@GetMapping("/testThredData")
public List testThredData(){
return blogService.getAllResult();
}
service层
public interface IBlogService extends IService<Blog> {
//每个线程分页查询
public List<Blog> getQueryData(Integer start,Integer end);
//合并线程结果
public List getAllResult();
}
serviceImpl层
@Service
public class BlogServiceImpl extends ServiceImpl<BlogMapper, Blog> implements IBlogService {
@Resource
private BlogMapper blogMapper;
@Autowired
private MultiThreadQueryUtil multiThreadQueryUtil;
//每个线程分页查询
@Override
public List<Blog> getQueryData(Integer start, Integer end) {
return this.blogMapper.getQueryData(start,end);
}
//合并线程结果
@Override
public List getAllResult() {
return multiThreadQueryUtil.getMultiCombineResult();
}
}
multiThreadQueryUtil工具类
@Service
public class MultiThreadQueryUtil {
/**
* 获取多线程结果并进行结果合并
* @return
*/
public List<List> getMultiCombineResult() {
//开始时间
long start = System.currentTimeMillis();
//返回结果
List<List> result = new ArrayList<>();
//查询数据库总数量
// int count = workflowTaskMapper.selectCountAll();
// Map<String,String> splitMap = ExcelLocalUtils.getSplitMap(count,5);
//假定总数据4条
//Callable用于产生结果
List<Callable<List>> tasks = new ArrayList<>();
for (int i = 1; i <= 4; i++) {
//不同的线程用户处理不同分段的数据量，这样就达到了平均分摊查询数据的压力
//这里让每个线程每次查询一条数据
int startNum =i-1;//对应的数据要和i挂钩 ，否则数据不变
int endNum =i;
Callable<List> qfe = new ThredQuery(startNum, endNum);
tasks.add(qfe);
}
try{
//定义固定长度的线程池 防止线程过多，5就够用了
// ExecutorService executorService = Executors.newFixedThreadPool(5);
//4条数据，分成4个线程来查询
ExecutorService executorService = Executors.newFixedThreadPool(4);
//Future用于获取结果
List<Future<List>> futures=executorService.invokeAll(tasks);
//处理线程返回结果
if(futures!=null&&futures.size() > 0){
for (Future<List> future:futures){
result.addAll(future.get());
}
}
//关闭线程池，一定不能忘记
executorService.shutdown();
}catch (Exception e){
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("线程查询数据用时:"+(end-start)+"ms");
return result;
}
}
Future相关的知识，可以参考这篇博客
https://blog.csdn.net/bobozai86/article/details/123978048
注意：startNum和endNum的值要和i相关，楼主一开始直接设固定值，通过自增来改变，后来发现这两个值没有变化，修改成和i相关即可解决
ThredQuery线程执行方法类
public class ThredQuery implements Callable<List> {
public static SpringContextUtil springContextUtil = new SpringContextUtil();
private int start;
private int end;
//每个线程查询出来的数据集合
private List datas;
public ThredQuery(int start,int end) {
this.start=start;
this.end=end;
//每个线程查询出来的数据集合
// QueryService queryService= springContextUtil.getBean("queryService");
//上面获取bean实例的方法可能会失效
IBlogService blogService = springContextUtil.getBean(IBlogService.class);
List count = blogService.getQueryData(start,end);
datas = count;
}
//返回数据给Future
@Override
public List call() throws Exception {
return datas;
}
}
这里线程继承了 Callable，多线程实现对list数据的处理
SpringContextUtil工具类
@Component
public class SpringContextUtil implements ApplicationContextAware {
/**
* 上下文对象实例
*/
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
/**
* 获取applicationContext
*
* @return
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
/**
* 获取HttpServletRequest
*/
public static HttpServletRequest getHttpServletRequest() {
return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
}
public static String getDomain(){
HttpServletRequest request = getHttpServletRequest();
StringBuffer url = request.getRequestURL();
return url.delete(url.length() - request.getRequestURI().length(), url.length()).toString();
}
public static String getOrigin(){
HttpServletRequest request = getHttpServletRequest();
return request.getHeader("Origin");
}
/**
* 通过name获取 Bean.
*
* @param name
* @return
*/
public static Object getBean(String name) {
return getApplicationContext().getBean(name);
}
/**
* 通过class获取Bean.
*
* @param clazz
* @param <T>
* @return
*/
public static <T> T getBean(Class<T> clazz) {
return getApplicationContext().getBean(clazz);
}
/**
* 通过name,以及Clazz返回指定的Bean
*
* @param name
* @param clazz
* @param <T>
* @return
*/
public static <T> T getBean(String name, Class<T> clazz) {
return getApplicationContext().getBean(name, clazz);
}
}
我们借助postman来测试一下，可以看到执行正常，不同的线程查询不同的数据，并合并在一起
