多线程批量插入数据

1. 批量插入数据

 /**
     * 批量插入数据
     */
    public void batchInsertData() throws InterruptedException {
        final Integer threadSize = 10;
        Scanner sc = new Scanner(System.in);
        final Long totalSize = 400000 + sc.nextLong();
        Long pageSize = (totalSize%threadSize == 0)?totalSize/threadSize:totalSize/threadSize+1;
        ExecutorService executorService = Executors.newFixedThreadPool(threadSize);
        Set<Integer> data;
        List<ThreadInsertDataDTO> list =new ArrayList<ThreadInsertDataDTO>();
        for (int i =1;i<threadSize;i++)
        {
            if (Objects.equals(i,threadSize)){
                pageSize = totalSize - (i - 1) * pageSize;
            }
            data = pageLimitSize(i,pageSize);
            list.add(new ThreadInsertDataDTO(articleService,data));
        }
        executorService.invokeAll(list);
    }

/**
     * 构造数据
     * @param i
     * @param pageSize
     * @return
     */
    public static Set pageLimitSize(int i,Long pageSize)
    {
        Set<Integer> set = new HashSet<Integer>();
        for (int j=0;j<10000;j++)
        {
            set.add(i*10000 + j);
        }
        return set;
    }

2.多线程处理类

package com.lzl.blog.util;

import com.lzl.blog.service.ArticleService;

import java.util.Set;
import java.util.concurrent.Callable;

public class ThreadInsertDataDTO implements Callable<Boolean> {

    private ArticleService articleService;

    private Set<Integer> set;

    public ArticleService getArticleService() {
        return articleService;
    }

    public Set<Integer> getSet() {
        return set;
    }

    public ThreadInsertDataDTO(ArticleService articleService, Set<Integer> set) {
        this.articleService = articleService;
        this.set = set;
    }

    @Override
    public Boolean call() throws Exception {
        if (null != articleService)
        {
            articleService.batchInsertData(set);
        }
        return true;
    }
}