使用Callable多线程实现对list数据的处理

1.简单介绍通过实现Callable接口创建线程
与Runable相比的区别在于：runable没有返回值，
Callable可以用Future<数据类型>接收返回值

class TaskWithResult implements Callable<String> {   //创建一个线程
    private int id;
    public TaskWithResult(int id) {
        this.id=id;
    }
    
    @Override
    public String call() throws Exception {
        return "result of TaskWithResult "+id;
    }
}

package com.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableTest {
    public static void main(String[] args) {
        ExecutorService exec=Executors.newCachedThreadPool();  //创建线程池
        List<Future<String>> results=new ArrayList<Future<String>>();  //定义接收返回值的list
        
        for(int i=0;i<5;i++) {
            results.add(exec.submit(new TaskWithResult(i))); //执行线程并添加返回值
        }
        
        for(Future<String> fs :results) {   //打印返回值
            try {
                System.out.println(fs.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }
}

2.利用多线程处理list中的数据

public class ThreadList {
 
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		List<String> list = new ArrayList<>(); //造list数据
		for(int i=0;i<5300;i++){
			list.add(""+i);
		}
		
		int threadSize = 500;//每500条数据开启一个线程
		int remainder = list.size()%threadSize;  //取余
		int threadNum  = 0; //线程数
		if(remainder == 0){ //能整除500
			threadNum  = list.size()/threadSize;
		} else {  //不能整除线程数要加1
			threadNum  = list.size()/threadSize + 1;
		}
		
		ExecutorService eService = Executors.newFixedThreadPool(threadNum ); //创建一个线程池
		List<Callable<String>> cList = new ArrayList<>();  //定义添加线程的集合
		Callable<String> task = null;  //创建单个线程
		List<String> sList = null;
		
		for(int i=0;i<threadNum;i++){  //根据线程数去取数据和创建线程
		
			if(i == threadNum - 1){
				sList = list.subList(i*threadSize, list.size());
			} else {
				sList = list.subList(i*threadSize, (i+1)*threadSize);
			}
			
			final List<String> nowList = sList;
			//创建单个线程
			task = new Callable<String>() {
				@Override
				public String call() throws Exception {
					StringBuffer sb = new StringBuffer();
					for(int j=0;j<nowList.size();j++){
						sb.append(""+nowList.get(j));
					}
					return sb.toString();
				}
			};
			cList.add(task); //添加线程
		}
		List<Future<String>> results = eService.invokeAll(cList); //执行所有创建的线程，并获取返回值（会把所有线程的返回值都返回）

		for(Future<String> str:results){  //打印返回值
			System.out.println(str.get());
		}
		eService.shutdown();
	}