SpringBoot利用线程池实现分片处理

SpringBoot利用线程池实现分片处理

一.前言

1.什么是分片处理

分片，就是主线程按照一定的大小将整个数据分隔成多个数据块后再利用子线程来对每个数据块进行分别处理，所有子线程都处理完毕后，在处理主线程后面的逻辑。

二.代码实现

1.整合线程池

整合线程池可以参考SpringBoot整合线程池

2.编写CountDownTemplate类

该类是一个抽象类主要有两个方法一个是countDownLaunch用于给线程分配任务，另一个是dealData用于每个线程对自己分到的数据进行逻辑处理，需要我们自己重写。

package com.ls.demo.user.data.common.template;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;

/**
 * 线程分片处理模板抽象类
 *
 * @param <T>
 */
public abstract class CountDownTemplate<T> {

    /**
     * 将线程池从ioc容器中依赖注入进来
     */
    @Qualifier("getThreadPoolTaskExecutor")
    @Autowired
    private Executor threadPoolTaskExecutor;

    /**
     * 用于给线程分配任务
     *
     * @param records  任务总数
     * @param pageSize 每个线程分到的任务数
     */
    public void countDownLaunch(List<T> records, int pageSize) throws InterruptedException {
        //如果传过来一个空list，跳出此函数
        if (records.size() == 0) {
            return;
        }
        int dealThread = (int) Math.ceil(records.size() / (double) pageSize);
        //CountDownLatch的计数器为处理的线程数dealThread
        CountDownLatch countDownLatch = new CountDownLatch(dealThread);
        //开始分配任务，每个线程处理pageSize个（如果最后一个线程处理不足pageSize个则会处理余下的任务）
        for (int i = 0; i < dealThread; i++) {
            int start, end;
            start = i * pageSize;
            end = (i + 1) * pageSize;
            if (end > records.size()) {
                end = records.size();
            }
            List<T> dealList = records.subList(start, end);
            //线程处理任务
            threadPoolTaskExecutor.execute(() -> {
                try {
                    dealData(dealList);
                    //放到finally块中，保证此方法一定执行。
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        //等待子线程 全部执行完毕 再执行
        countDownLatch.await(45, TimeUnit.SECONDS);
    }

    /**
     * 用于每个线程对自己分到的数据进行逻辑处理
     */
    protected abstract void dealData(List<T> data);

}

3.编写Demo类

我们编写Demo类来实现CountDownTemplate类并实现InitializingBean接口，重写InitializingBean接口的afterPropertiesSet方法并在该方法中中调用CountDownTemplate类的countDownLaunch方法来给子线程分配任务并重写该类的dealData方法处理每个子线程的业务逻辑。
我们为什么要实现InitializingBean接口呢？因为在spring的bean的生命周期中，实例化->生成对象->属性填充后会执行InitializingBean接口的afterPropertiesSet方法。

package com.ls.demo.user.data.common.template;

import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * 线程批次处理测试类
 */
@Component
@Log4j2
public class Demo extends CountDownTemplate<String> implements InitializingBean {

    /**
     * 初始化一个list，来装我们的测试数据。
     */
    private final List<String> records = new ArrayList<>();

    /**
     * 向我们的list中添加一些数据
     */
    public Demo() {
        for (int i = 0; i < 11; i++) {
            this.records.add(String.valueOf(i));
        }
    }

    /**
     * 给子线程分配任务
     * 在spring的bean的生命周期中，实例化->生成对象->属性填充后会执行InitializingBean接口的afterPropertiesSet方法
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("主线程开始给子线程分发任务{}", records);
        int pageSize = 3;
        countDownLaunch(records, pageSize);
        log.info("所有子线程的任务全部处理完毕，，主线程可以处理后续的逻辑了");
    }

    /**
     * 每个子线程各自处理自己的业务
     */
    @Override
    protected void dealData(List<String> data) {
        log.info("线程{}执行的数据为{}", Thread.currentThread().getName(), data);
    }

}

三.测试

我们启动我们的项目，可以看到我们的11条测试数据，分别被主线程分成4份（我们设置的每份应处理的量是3个，但最后一个不足三个所以只处理了两个），交给了子线程来处理。