多线程批量操作数据

如果数据量比较大，建议采用批量进行操作数据，以下是我写的一个Demo,可以根据自己的业务进行实现

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;
import java.util.concurrent.atomic.AtomicLong;

public class ThreadTest {
    private static int threadNum = 100;
    private static int totalSeconds = 180;
    private static AtomicLong totalCount = new AtomicLong(0);
	public static void main(String[] args) {
        try {
            List<String> list = new ArrayList<String>();
            for (int i = 0; i < 1000; i++) {
                list.add(i + ",");
            }

            System.out.println(list2Str(list, 5));
        } catch (Exception e) {
            e.printStackTrace();
        }
		/*ArrayList<Thread> threads = new ArrayList<Thread>();
        for (int i = 0; i < threadNum; ++i){
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    try {
                    	//处理逻辑
                    	
                    	
                    	
                        long count = 0;
                        long startTime = System.currentTimeMillis();

                        System.out.println(startTime);
                        long endTime = startTime + totalSeconds * 1000;

                        System.out.println(System.currentTimeMillis());
                        System.out.println("Thread" + Thread.currentThread().getName() + ": " + String.valueOf(count));
                        totalCount.addAndGet(count);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }, String.valueOf(i));
            thread.start();
            threads.add(thread);
        }

        for (int i = 0; i < threadNum; ++i) {
            try {
                threads.get(i).join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }*/
    }
	/**
	*@param   list 集合
	*@param   nThreads 线程数
	*/
    public static 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>() {
                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();
    }
}