import java.util.ArrayList;  
    import java.util.List;  
    import java.util.concurrent.Callable;  
    import java.util.concurrent.ExecutorService;  
    import java.util.concurrent.Executors;  
    import java.util.concurrent.Future;  
      
    public class Test {  
      
        public static void main(String[] args) {  
            try {  
                List<String> list = new ArrayList<>();  
                for (int i = 0; i < 100; i++) {  
                    list.add(i + ",");  
                }  
                  
                System.out.println(new Test().list2Str(list, 5));  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
      
        public String list2Str(List<String> list, final int nThreads) throws Exception {  
            if (list == null || list.isEmpty()) {  
                return null;  
            }  
              
            StringBuffer ret = new StringBuffer();  
      
            int size = list.size();  
            ExecutorService executorService = Executors.newFixedThreadPool(nThreads);  
            List<Future<String>> futures = new ArrayList<Future<String>>(nThreads);  
              
            for (int i = 0; i < nThreads; i++) {  
                final List<String> subList = list.subList(size / nThreads * i, size / nThreads * (i + 1));  
                Callable<String> task = new Callable<String>() {  
                    @Override  
                    public String call() throws Exception {  
                        StringBuffer sb = new StringBuffer();  
                        for (String str : subList) {  
                            sb.append(str);  
                        }  
                        return sb.toString();  
                    }  
                };  
                futures.add(executorService.submit(task));  
            }  
              
            for (Future<String> future : futures) {  
                ret.append(future.get());  
            }  
            executorService.shutdown();  
              
            return ret.toString();  
        }  
    }  
 

public void dealListWithMutiThread(){
        List<Object> list = new ArrayList<Object>(10000);
        int index = 0;
        ExecutorService ex = Executors.newFixedThreadPool(5);
        int dealSize = 2000;
        List<Future<List<Object>>> futures = new ArrayList<>(5);
                //分配
        for(int i=0;i<5;i++){
            int start = index;
            if(start>=list.size()) break;
            int end = start + dealSize;
            end = end>list.size() ? list.size() : end;
 

<span style="white-space:pre">			</span>index+=dealSize;
            futures.add(ex.submit(new Task(list,start,end)));
        }
        try {
            //處理
            List<Object>  result = new ArrayList<>();
            for(Future<List<Object>> future : futures){
                //合併操作
                result.addAll(future.get());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     
    private class Task implements Callable<List<Object>>{
         
        private List<Object> list;
        private int start;
        private int end;
         
        public Task(List<Object> list,int start,int end){
            this.list = list;
            this.start = start;
            this.end = end;
        }
 
        @Override
        public List<Object> call() throws Exception {
            Object obj = null;
            List<Object> retList = new ArrayList<Object>();
            for(int i=start;i<end;i++){
                obj = list.get(i);
                //你的處理邏輯
            }
            //返回處理結果
            return retList;
        }
    }