使用线程池处理list数据

1.业务场景：从数据库中读取一个list集合，使用线程池分别对list的数据做处理，不能重复处理。

2.ThreadPoolTaskExecutor实现。

---

代码实现：业务类

 

package com.thread;

import java.util.List;
import java.util.concurrent.Callable;

public class SunCallable implements Callable<Boolean>{
    
     /**当前是属于第几段线程**/  
    private int pageIndex;  
      
    private List<String> list;  
       
    public SunCallable(int pageIndex,List<String> list){  
        this.pageIndex = pageIndex;  
        this.list = list;  
    }  
       
    @Override  
    public Boolean call() throws Exception {  
                System.err.println(String.format("pageIndex:%s size:%s",pageIndex,list.size()));  
        Boolean result = Boolean.TRUE;  
        if(null != list && list.size() >0){  
            for(String str: list){  
                try {  
                     System.out.println(pageIndex+"::::"+str);

//调用业务方法
                     handleStr(str);
                } catch (Exception e) {  
                    result = Boolean.FALSE;;  
                       
                }  
            }  
        }  
        return result;  
    } 
    /**
     * 业务处理
     * @param str
     * @throws InterruptedException
     */
    public void handleStr(String str) throws InterruptedException {
        Thread.sleep(1000);
    }

}
2.线程池的业务处理

package com.thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
/**
 * 多线程的使用
 * @author syn
 *2019年1月8日
 *
 */
public class RunThread {
     
    private  ThreadPoolTaskExecutor taskExecutor ; 
    public RunThread (Integer corePoolSize,Integer maxPoolSize ) {
        taskExecutor =new ThreadPoolTaskExecutor(); 
        taskExecutor.initialize();
        taskExecutor.setCorePoolSize(corePoolSize);
        taskExecutor.setMaxPoolSize(maxPoolSize);
    }
    /**
     * 
     * @param list 需要处理的list
     * @param sunSum 将集合切分的段数
     * @throws InterruptedException
     * @throws ExecutionException
     */
    @SuppressWarnings("unused")
    private void doReadList(List<String> list,int sunSum ) throws InterruptedException, ExecutionException{  
        /**初始化集合**/  
       
          
        /**接收集合各段的 执行的返回结果**/  
        List<Future<Boolean>> futureList = new ArrayList<Future<Boolean>>();  
          
        /**集合总条数**/  
        int size = list.size();  
        /**将集合切分的段数**/  
        //int sunSum = 10;  
        int listStart,listEnd;  
        /***当总条数不足10条时 用总条数 当做线程切分值**/  
        if(sunSum > size){  
            sunSum = size;  
        }  
        /**定义子线程**/  
        SunCallable sunCallable=null ;  
        /**将list 切分10份 多线程执行**/  
        for (int i = 0; i < sunSum; i++) {  
            /***计算切割  开始和结束**/  
            listStart = size / sunSum * i ;  
            listEnd = size / sunSum * ( i + 1 );  
            /**最后一段线程会 出现与其他线程不等的情况**/  
            if(i == sunSum - 1){  
                listEnd = size;  
            }  
            /**线程切断**/  
            List<String> sunList = list.subList(listStart,listEnd);   
            /**子线程初始化**/  
            sunCallable = new SunCallable(i,sunList);  
            /***多线程执行***/  
            futureList.add(taskExecutor.submit(sunCallable));  
        }  
        /**对各个线程段结果进行解析**/  
        for(Future<Boolean> future : futureList){  
            if(null != future && future.get()){  
                System.err.println("成功");  
            }else{  
                System.err.println("失败");  
            }  
        }  
    } 

/**

*测试方法

*/
    public static void main(String[] args) {
         List<String> list = new ArrayList<String>();  
         for(int i=0;i<123;i++){  
             list.add("test--"+i);  
         }
        long start=System.currentTimeMillis();
        RunThread   runThread=new RunThread(8,8);
        try {
            runThread.doReadList(list,8);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("执行程序用时："+(System.currentTimeMillis()-start));
    }
}