多线程分批处理千万级数据示例场景

最新推荐文章于 2024-02-29 23:28:10 发布
最新推荐文章于 2024-02-29 23:28:10 发布
阅读量3k 收藏 49
点赞数 5
分类专栏： 【Java-并发编程】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MyronCham/article/details/106964388
版权

1、ListUtils工具类（提供将List均分成n个list和将List分成每份count数量的List操作）

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ListUtils {
	
	/**
	 * 	将一个list均分成n个list：
	 * @param source
	 * @param n 
	 * @return
	 */
	public static <T> List<List<T>> avgList(List<T> source, int n) {
	    List<List<T>> result = new ArrayList<>();
		//(先计算出余数)
	    int remainder = source.size() % n;  
	    //然后是商
	    int number = source.size() / n;  
		//偏移量
	    int offset = 0;
	    for (int i = 0; i < n; i++) {
	        List<T> value;
	        if (remainder > 0) {
	            value = source.subList(i * number + offset, (i + 1) * number + offset + 1);
	            remainder--;
	            offset++;
	        } else {
	            value = source.subList(i * number + offset, (i + 1) * number + offset);
	        }
	        result.add(value);
	    }
	    return result;
	}
	
	/**
	 * 	将list分成每份count的数量的list：
	 * @param resList
	 * @param count
	 * @return
	 */
	public static <T> List<List<T>> splitList(List<T> resList, int count) {  
        if (resList == null || count < 1) {
        	return null;  
        }
       
        //long t1 = System.currentTimeMillis();
        List<List<T>> result = new ArrayList<List<T>>();  
        int size = resList.size();  
        if (size <= count) {  
            // 数据量不足count指定的大小  
        	result.add(resList);  
        } else {  
            int pre = size / count;  
            int last = size % count;  
            // 前面pre个集合，每个大小都是count个元素  
            for (int i = 0; i < pre; i++) {  
                List<T> itemList = new ArrayList<T>();  
                for (int j = 0; j < count; j++) {  
                    itemList.add(resList.get(i * count + j));  
                }  
                result.add(itemList);  
            }  
            // last的进行处理  
            if (last > 0) {  
                List<T> itemList = new ArrayList<T>();  
                for (int i = 0; i < last; i++) {  
                    itemList.add(resList.get(pre * count + i));  
                }  
                result.add(itemList);  
            }  
        }  
        /*long t2 = System.currentTimeMillis();
        System.out.println("splitList====>>> resList.size:" + resList.size()
        + ", count:" +count + ", costs time:" + (t2 - t1) + " ms");*/
        return result;  
    }
	
	public static <T> List<List<T>> splitList2(List<T> list, int count) { //效率低不推荐使用
		long t1 = System.currentTimeMillis();
		int limit = (list.size() + count - 1) / count;
		// 方法一：使用流遍历操作
		/*List<List<T>> result = new ArrayList<>();
		Stream.iterate(0, n -> n + 1).limit(limit).forEach(i -> {
			result.add(list.stream().skip(i * count).limit(count).collect(Collectors.toList()));
		});*/
		//方法二：获取分割后的集合
	    List<List<T>> result = Stream.iterate(0, n -> n + 1).limit(limit).parallel().map(a -> list.stream().skip(a * count).limit(count).parallel().collect(Collectors.toList())).collect(Collectors.toList());
	    long t2 = System.currentTimeMillis();
        System.out.println("splitList====>>> resList.size:" + list.size()
        + ", count:" +count + ", costs time:" + (t2 - t1) + " ms");
		return result;  
	}
	
	public static void main(String[] args) {
		/*List<Integer> list=new ArrayList<>();
		for (int i = 0; i < 17; i++) {
			list.add(i);
		}
		List<List<Integer>> avgList = avgList(list, 5);
		System.out.println("avgList: " + avgList);
		
		List<List<Integer>> splitList = splitList(list, 5);
		System.out.println("splitList: " + splitList);
		
		ArrayList<Integer> arr_list = new ArrayList<>();
		for (int i = 0; i < splitList.size(); i++) {
			List<Integer> subList = splitList.get(i);
			arr_list.addAll(subList);
		}
		System.out.println("arr_list: " + arr_list);*/
		
	}
	
}

2、模拟一千万请求数据，创建一个线程池10线程个控制最大并发数，每个线程一次处理10万条，开启100个线程。（用于控制每个批次线程的数据量业务场景）

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.test.utils.ListUtils;

public class ConcurrencyTest {
	
	public static void main(String[] args) {
		int count = 10000000;
		List<Long> listKey = new ArrayList<>();
		for (int i = 0; i < count; i++) {
			listKey.add(114560315500000000L + i);
		}
		ConcurrencyTest concurrencyTest = new ConcurrencyTest();
                List<Long> valueList1 = concurrencyTest.getValueList1(listKey);
                System.out.println("====>> getValueList1 valueList.size: " + valueList1.size());	
	}

	private final static Logger log = LoggerFactory.getLogger(ConcurrencyTest.class);

	/**
	 * 模拟一千万请求数据，创建一个线程池10个线程控制最大并发数，每个线程一次处理10万条，开启100个线程。（用于控制每批次线程的数据量业务场景）
	 * @param listKey 请求处理的总数据量
	 * @return
	 */
	public List<Long> getValueList1(List<Long> listKey) {
		
		/**
		（1）newCachedThreadPool		创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
    	        （2）newFixedThreadPool 		创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
    	        （3）newScheduledThreadPool	创建一个定长线程池，支持定时及周期性任务执行。
    	        （4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
    	         */
		//创建一个线程池
		final ExecutorService executorService = Executors.newFixedThreadPool(10); //用于控制同时并发执行的线程数，使用线程池创建资源提高效率
		List<Long> list_val = Collections.synchronizedList(new ArrayList<>()); //保证多线程操作的是同一个List
		try {
			long t1 = System.currentTimeMillis();
			int max_one_batch = 100000; // 一批次最多处理100000条数据
			List<List<Long>> newList = ListUtils.splitList(listKey, max_one_batch);
			int runSize = newList.size(); // 开启的线程数

			/**
			 * CountDownLanch 只需要在子线程执行之前, 赋予初始化countDownLanch, 并赋予线程数量为初始值。
			 * 每个线程执行完毕的时候, 就countDown一下。主线程只需要调用await方法, 可以等待所有子线程执行结束。
			 */
			final CountDownLatch countDownLatch = new CountDownLatch(runSize); //计数器
			
			/**
			 * Semaphore（信号量）是用来控制同时访问特定资源的线程数量，拿到信号量的线程可以进入，否则就等待。
			 * 通过acquire()和release()获取和释放访问许可。
			 */
			final Semaphore semaphore = new Semaphore(runSize); //信号量
			// 循环创建线程
			for (int j = 0; j < runSize; j++) {
				final int i = j;
				executorService.execute(new Runnable() {
					@Override
					public void run() {
						try {
							semaphore.acquire();
							// 执行程序
							List<Long> subList = newList.get(i);
							List<Long> sub_ret = getValue(subList);
							list_val.addAll(sub_ret);
							log.info(Thread.currentThread().getName() + ": 当前线程/总线程: [" + i + "/" + runSize + "]"
									+ ", 处理的数据条数：" + subList.size());
							semaphore.release();
						} catch (Exception e) {
							log.error(e.getMessage(), e);
						} finally {
							// 计数器减一
							countDownLatch.countDown();
						}
					}
				});
			}

			// 阻塞主线程等待所有线程执行完成
			countDownLatch.await();
			// 所有线程执行完，之后才能执行的部分
			long t2 = System.currentTimeMillis();
			log.info("Call getValueList1 success... ret: {} size, threadCount: {},  costs time: {} ms", list_val.size(), runSize, (t2 - t1));
			return list_val;
		} catch (Exception e) {
			return null;
		} finally {
			// 关闭线程池
			executorService.shutdown();
		}
	}
    
    private List<Long> getValue(List<Long> listKey) {
	//具体操作省略
	return listKey;
    }

}

测试日志记录：

01:11:17.515 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [3/100], 处理的数据条数：100000
01:11:17.515 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [7/100], 处理的数据条数：100000
01:11:17.515 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [0/100], 处理的数据条数：100000
01:11:17.515 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [9/100], 处理的数据条数：100000
01:11:17.515 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [1/100], 处理的数据条数：100000
01:11:17.516 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [8/100], 处理的数据条数：100000
01:11:17.515 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [4/100], 处理的数据条数：100000
01:11:17.515 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [2/100], 处理的数据条数：100000
01:11:17.516 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [5/100], 处理的数据条数：100000
01:11:17.516 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [6/100], 处理的数据条数：100000
01:11:17.520 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [10/100], 处理的数据条数：100000
01:11:17.520 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [19/100], 处理的数据条数：100000
01:11:17.520 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [20/100], 处理的数据条数：100000
01:11:17.520 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [18/100], 处理的数据条数：100000
01:11:17.521 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [17/100], 处理的数据条数：100000
01:11:17.522 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [16/100], 处理的数据条数：100000
01:11:17.523 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [15/100], 处理的数据条数：100000
01:11:17.523 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [14/100], 处理的数据条数：100000
01:11:17.523 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [13/100], 处理的数据条数：100000
01:11:17.523 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [12/100], 处理的数据条数：100000
01:11:17.523 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [11/100], 处理的数据条数：100000
01:11:17.523 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [29/100], 处理的数据条数：100000
01:11:17.526 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [28/100], 处理的数据条数：100000
01:11:17.527 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [27/100], 处理的数据条数：100000
01:11:17.527 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [32/100], 处理的数据条数：100000
01:11:17.527 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [26/100], 处理的数据条数：100000
01:11:17.527 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [25/100], 处理的数据条数：100000
01:11:17.527 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [24/100], 处理的数据条数：100000
01:11:17.528 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [23/100], 处理的数据条数：100000
01:11:17.528 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [22/100], 处理的数据条数：100000
01:11:17.528 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [21/100], 处理的数据条数：100000
01:11:17.528 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [39/100], 处理的数据条数：100000
01:11:17.528 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [38/100], 处理的数据条数：100000
01:11:17.528 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [37/100], 处理的数据条数：100000
01:11:17.645 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [36/100], 处理的数据条数：100000
01:11:17.645 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [35/100], 处理的数据条数：100000
01:11:17.646 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [34/100], 处理的数据条数：100000
01:11:17.646 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [33/100], 处理的数据条数：100000
01:11:17.646 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [31/100], 处理的数据条数：100000
01:11:17.646 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [30/100], 处理的数据条数：100000
01:11:17.647 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [48/100], 处理的数据条数：100000
01:11:17.647 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [47/100], 处理的数据条数：100000
01:11:17.647 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [46/100], 处理的数据条数：100000
01:11:17.647 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [45/100], 处理的数据条数：100000
01:11:17.647 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [44/100], 处理的数据条数：100000
01:11:17.648 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [43/100], 处理的数据条数：100000
01:11:17.648 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [42/100], 处理的数据条数：100000
01:11:17.648 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [41/100], 处理的数据条数：100000
01:11:17.648 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [40/100], 处理的数据条数：100000
01:11:17.648 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [57/100], 处理的数据条数：100000
01:11:17.649 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [56/100], 处理的数据条数：100000
01:11:17.655 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [55/100], 处理的数据条数：100000
01:11:17.656 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [53/100], 处理的数据条数：100000
01:11:17.656 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [62/100], 处理的数据条数：100000
01:11:17.655 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [54/100], 处理的数据条数：100000
01:11:17.656 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [52/100], 处理的数据条数：100000
01:11:17.657 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [65/100], 处理的数据条数：100000
01:11:17.657 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [51/100], 处理的数据条数：100000
01:11:17.657 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [50/100], 处理的数据条数：100000
01:11:17.657 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [49/100], 处理的数据条数：100000
01:11:17.657 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [68/100], 处理的数据条数：100000
01:11:17.657 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [67/100], 处理的数据条数：100000
01:11:17.658 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [66/100], 处理的数据条数：100000
01:11:17.658 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [64/100], 处理的数据条数：100000
01:11:17.658 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [63/100], 处理的数据条数：100000
01:11:17.658 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [61/100], 处理的数据条数：100000
01:11:17.659 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [60/100], 处理的数据条数：100000
01:11:17.659 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [59/100], 处理的数据条数：100000
01:11:17.659 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [58/100], 处理的数据条数：100000
01:11:17.659 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [77/100], 处理的数据条数：100000
01:11:17.659 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [76/100], 处理的数据条数：100000
01:11:17.659 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [75/100], 处理的数据条数：100000
01:11:17.660 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [74/100], 处理的数据条数：100000
01:11:17.660 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [73/100], 处理的数据条数：100000
01:11:17.660 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [72/100], 处理的数据条数：100000
01:11:17.660 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [71/100], 处理的数据条数：100000
01:11:17.794 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [70/100], 处理的数据条数：100000
01:11:17.795 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [69/100], 处理的数据条数：100000
01:11:17.795 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [86/100], 处理的数据条数：100000
01:11:17.795 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [85/100], 处理的数据条数：100000
01:11:17.796 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [84/100], 处理的数据条数：100000
01:11:17.796 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [90/100], 处理的数据条数：100000
01:11:17.797 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [91/100], 处理的数据条数：100000
01:11:17.797 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [92/100], 处理的数据条数：100000
01:11:17.797 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [83/100], 处理的数据条数：100000
01:11:17.797 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [82/100], 处理的数据条数：100000
01:11:17.798 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [81/100], 处理的数据条数：100000
01:11:17.798 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [80/100], 处理的数据条数：100000
01:11:17.798 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [79/100], 处理的数据条数：100000
01:11:17.798 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [78/100], 处理的数据条数：100000
01:11:17.798 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [98/100], 处理的数据条数：100000
01:11:17.799 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [97/100], 处理的数据条数：100000
01:11:17.799 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [96/100], 处理的数据条数：100000
01:11:17.799 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [94/100], 处理的数据条数：100000
01:11:17.799 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [95/100], 处理的数据条数：100000
01:11:17.799 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [93/100], 处理的数据条数：100000
01:11:17.800 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [89/100], 处理的数据条数：100000
01:11:17.800 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [88/100], 处理的数据条数：100000
01:11:17.800 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [87/100], 处理的数据条数：100000
01:11:17.800 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [99/100], 处理的数据条数：100000
01:11:17.800 [main] INFO com.test.thread.ConcurrencyTest - Call getValueList1 success... ret: 10000000 size, threadCount: 100,  costs time: 629 ms
====>> getValueList1 valueList.size: 10000000

3、模拟一千万请求数据，创建一个线程池10个线程控制最大并发数，设置请求的线程数为100，平均处理这一千万请求数据。（用于控制请求线程数的业务场景）

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.test.utils.ListUtils;

public class ConcurrencyTest {
	
	public static void main(String[] args) {
		int count = 10000000;
		List<Long> listKey = new ArrayList<>();
		for (int i = 0; i < count; i++) {
			listKey.add(114560315500000000L + i);
		}
		ConcurrencyTest concurrencyTest = new ConcurrencyTest();
		List<Long> valueList2 = concurrencyTest.getValueList2(listKey);
		System.out.println("====>> getValueList2 valueList.size: " + valueList2.size());
		
		
	}

	private final static Logger log = LoggerFactory.getLogger(ConcurrencyTest.class);



	/**
	 * 模拟一千万请求数据，创建一个线程池10个线程控制最大并发数，设置请求的线程数为100，平均处理这一千万请求数据。（用于控制请求线程数的业务场景）
	 * @param listKey 请求处理的总数据量
	 * @return
	 */
	public List<Long> getValueList2(List<Long> listKey) {
		
		/**
		（1）newCachedThreadPool		创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
    	        （2）newFixedThreadPool 		创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
    	        （3）newScheduledThreadPool	创建一个定长线程池，支持定时及周期性任务执行。
    	        （4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
    	         */
		//创建一个线程池
		final ExecutorService executorService = Executors.newFixedThreadPool(10); //用于控制同时并发执行的线程数，使用线程池创建资源提高效率
		List<Long> list_val = Collections.synchronizedList(new ArrayList<>()); //保证多线程操作的是同一个List
		try {
			long t1 = System.currentTimeMillis();
			int threadCount = 100; //请求的线程数
			List<List<Long>> newList = ListUtils.avgList(listKey, threadCount);
			int runSize = threadCount; // 请求开启的线程数
			
			/**
			 * CountDownLanch 只需要在子线程执行之前, 赋予初始化countDownLanch, 并赋予线程数量为初始值。
			 * 每个线程执行完毕的时候, 就countDown一下。主线程只需要调用await方法, 可以等待所有子线程执行结束。
			 */
			final CountDownLatch countDownLatch = new CountDownLatch(runSize); //计数器
			
			/**
			 * Semaphore（信号量）是用来控制同时访问特定资源的线程数量，拿到信号量的线程可以进入，否则就等待。
			 * 通过acquire()和release()获取和释放访问许可。
			 */
			final Semaphore semaphore = new Semaphore(runSize); //信号量
			// 循环创建线程
			for (int j = 0; j < runSize; j++) {
				final int i = j;
				executorService.execute(new Runnable() {
					@Override
					public void run() {
						try {
							semaphore.acquire();
							// 执行程序
							List<Long> subList = newList.get(i);
							List<Long> sub_ret = getValue(subList);
							list_val.addAll(sub_ret);
							log.info(Thread.currentThread().getName() + ": 当前线程/总线程: [" + i + "/" + runSize + "]"
									+ ", 处理的数据条数：" + subList.size());
							semaphore.release();
						} catch (Exception e) {
							log.error(e.getMessage(), e);
						} finally {
							// 计数器减一
							countDownLatch.countDown();
						}
					}
				});
			}

			// 阻塞主线程等待所有线程执行完成
			countDownLatch.await();
			// 所有线程执行完，之后才能执行的部分
			long t2 = System.currentTimeMillis();
			log.info("Call getValueList2 success... ret: {} size, threadCount: {},  costs time: {} ms", list_val.size(), runSize, (t2 - t1));
			return list_val;
		} catch (Exception e) {
			return null;
		} finally {
			// 关闭线程池
			executorService.shutdown();
		}
	}
	
	private List<Long> getValue(List<Long> listKey) {
		//具体操作省略
		return listKey;
	}
}

测试日志记录：

01:16:05.076 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [8/100], 处理的数据条数：100000
01:16:05.076 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [9/100], 处理的数据条数：100000
01:16:05.079 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [4/100], 处理的数据条数：100000
01:16:05.075 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [0/100], 处理的数据条数：100000
01:16:05.076 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [7/100], 处理的数据条数：100000
01:16:05.078 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [6/100], 处理的数据条数：100000
01:16:05.081 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [3/100], 处理的数据条数：100000
01:16:05.082 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [5/100], 处理的数据条数：100000
01:16:05.082 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [1/100], 处理的数据条数：100000
01:16:05.083 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [2/100], 处理的数据条数：100000
01:16:05.085 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [18/100], 处理的数据条数：100000
01:16:05.086 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [17/100], 处理的数据条数：100000
01:16:05.086 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [16/100], 处理的数据条数：100000
01:16:05.086 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [15/100], 处理的数据条数：100000
01:16:05.087 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [14/100], 处理的数据条数：100000
01:16:05.088 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [13/100], 处理的数据条数：100000
01:16:05.089 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [12/100], 处理的数据条数：100000
01:16:05.089 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [11/100], 处理的数据条数：100000
01:16:05.089 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [10/100], 处理的数据条数：100000
01:16:05.090 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [27/100], 处理的数据条数：100000
01:16:05.090 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [26/100], 处理的数据条数：100000
01:16:05.090 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [25/100], 处理的数据条数：100000
01:16:05.093 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [24/100], 处理的数据条数：100000
01:16:05.093 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [23/100], 处理的数据条数：100000
01:16:05.094 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [22/100], 处理的数据条数：100000
01:16:05.094 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [21/100], 处理的数据条数：100000
01:16:05.094 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [20/100], 处理的数据条数：100000
01:16:05.095 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [19/100], 处理的数据条数：100000
01:16:05.095 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [36/100], 处理的数据条数：100000
01:16:05.096 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [35/100], 处理的数据条数：100000
01:16:05.096 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [34/100], 处理的数据条数：100000
01:16:05.096 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [33/100], 处理的数据条数：100000
01:16:05.097 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [32/100], 处理的数据条数：100000
01:16:05.097 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [31/100], 处理的数据条数：100000
01:16:05.101 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [30/100], 处理的数据条数：100000
01:16:05.101 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [29/100], 处理的数据条数：100000
01:16:05.102 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [28/100], 处理的数据条数：100000
01:16:05.102 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [45/100], 处理的数据条数：100000
01:16:05.102 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [44/100], 处理的数据条数：100000
01:16:05.103 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [43/100], 处理的数据条数：100000
01:16:05.103 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [42/100], 处理的数据条数：100000
01:16:05.103 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [41/100], 处理的数据条数：100000
01:16:05.104 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [40/100], 处理的数据条数：100000
01:16:05.104 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [39/100], 处理的数据条数：100000
01:16:05.105 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [38/100], 处理的数据条数：100000
01:16:05.105 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [37/100], 处理的数据条数：100000
01:16:05.106 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [54/100], 处理的数据条数：100000
01:16:05.106 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [53/100], 处理的数据条数：100000
01:16:05.106 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [52/100], 处理的数据条数：100000
01:16:05.107 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [51/100], 处理的数据条数：100000
01:16:05.107 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [50/100], 处理的数据条数：100000
01:16:05.246 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [49/100], 处理的数据条数：100000
01:16:05.247 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [48/100], 处理的数据条数：100000
01:16:05.247 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [61/100], 处理的数据条数：100000
01:16:05.248 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [47/100], 处理的数据条数：100000
01:16:05.248 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [46/100], 处理的数据条数：100000
01:16:05.249 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [64/100], 处理的数据条数：100000
01:16:05.249 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [63/100], 处理的数据条数：100000
01:16:05.249 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [62/100], 处理的数据条数：100000
01:16:05.250 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [60/100], 处理的数据条数：100000
01:16:05.250 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [59/100], 处理的数据条数：100000
01:16:05.251 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [58/100], 处理的数据条数：100000
01:16:05.251 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [57/100], 处理的数据条数：100000
01:16:05.251 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [56/100], 处理的数据条数：100000
01:16:05.252 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [55/100], 处理的数据条数：100000
01:16:05.252 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [73/100], 处理的数据条数：100000
01:16:05.252 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [72/100], 处理的数据条数：100000
01:16:05.253 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [71/100], 处理的数据条数：100000
01:16:05.253 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [70/100], 处理的数据条数：100000
01:16:05.254 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [69/100], 处理的数据条数：100000
01:16:05.254 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [68/100], 处理的数据条数：100000
01:16:05.254 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [67/100], 处理的数据条数：100000
01:16:05.255 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [66/100], 处理的数据条数：100000
01:16:05.256 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [65/100], 处理的数据条数：100000
01:16:05.256 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [82/100], 处理的数据条数：100000
01:16:05.257 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [81/100], 处理的数据条数：100000
01:16:05.266 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [80/100], 处理的数据条数：100000
01:16:05.267 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [79/100], 处理的数据条数：100000
01:16:05.267 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [78/100], 处理的数据条数：100000
01:16:05.267 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [77/100], 处理的数据条数：100000
01:16:05.268 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [76/100], 处理的数据条数：100000
01:16:05.268 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [75/100], 处理的数据条数：100000
01:16:05.269 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [74/100], 处理的数据条数：100000
01:16:05.269 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [91/100], 处理的数据条数：100000
01:16:05.270 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [90/100], 处理的数据条数：100000
01:16:05.270 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [89/100], 处理的数据条数：100000
01:16:05.270 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [88/100], 处理的数据条数：100000
01:16:05.271 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [87/100], 处理的数据条数：100000
01:16:05.271 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [86/100], 处理的数据条数：100000
01:16:05.272 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [85/100], 处理的数据条数：100000
01:16:05.272 [pool-1-thread-10] INFO com.test.thread.ConcurrencyTest - pool-1-thread-10: 当前线程/总线程: [84/100], 处理的数据条数：100000
01:16:05.272 [pool-1-thread-9] INFO com.test.thread.ConcurrencyTest - pool-1-thread-9: 当前线程/总线程: [83/100], 处理的数据条数：100000
01:16:05.273 [pool-1-thread-1] INFO com.test.thread.ConcurrencyTest - pool-1-thread-1: 当前线程/总线程: [99/100], 处理的数据条数：100000
01:16:05.273 [pool-1-thread-5] INFO com.test.thread.ConcurrencyTest - pool-1-thread-5: 当前线程/总线程: [98/100], 处理的数据条数：100000
01:16:05.274 [pool-1-thread-8] INFO com.test.thread.ConcurrencyTest - pool-1-thread-8: 当前线程/总线程: [97/100], 处理的数据条数：100000
01:16:05.274 [pool-1-thread-7] INFO com.test.thread.ConcurrencyTest - pool-1-thread-7: 当前线程/总线程: [96/100], 处理的数据条数：100000
01:16:05.276 [pool-1-thread-4] INFO com.test.thread.ConcurrencyTest - pool-1-thread-4: 当前线程/总线程: [95/100], 处理的数据条数：100000
01:16:05.276 [pool-1-thread-6] INFO com.test.thread.ConcurrencyTest - pool-1-thread-6: 当前线程/总线程: [94/100], 处理的数据条数：100000
01:16:05.277 [pool-1-thread-2] INFO com.test.thread.ConcurrencyTest - pool-1-thread-2: 当前线程/总线程: [93/100], 处理的数据条数：100000
01:16:05.277 [pool-1-thread-3] INFO com.test.thread.ConcurrencyTest - pool-1-thread-3: 当前线程/总线程: [92/100], 处理的数据条数：100000
01:16:05.277 [main] INFO com.test.thread.ConcurrencyTest - Call getValueList2 success... ret: 10000000 size, threadCount: 100,  costs time: 366 ms
====>> getValueList2 valueList.size: 10000000

 

 

 

 

 

一棵树～
关注
  • 5
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java多线程导出excel（千万级别）优化
12-05
轻松解决普通poi形式导出Excel的中出现的栈溢出问题，此资源可实现千万级数据分批导出csv文件，csv大数据量导出(千万级别，不会内存溢出)，多线程导出 ，生产环境已经很稳定的使用着
Java中处理千万级数据的最佳实践：性能优化指南
weixin_51151534的博客
10-04 1551
根据应用程序的特性，有时自定义数据结构可以提供更好的性能。例如，如果您需要高效存储大量的布尔值数据，可以考虑使用位集合（BitSet），它可以显著减小内存消耗。// 设置某些位为true bitSet . set(1);// 检查位的状态 boolean isSet = bitSet . get(100);// 返回true boolean isNotSet = bitSet . get(500);// 返回false } }// 设置某些位为true bitSet . set(1)
c++并发编程和多线程处理
最新发布
zhengddzz的博客
02-29 1245
开发者可以通过使用互斥锁、条件变量和原子操作等机制，来保证自己编写的代码在多线程环境中的线程安全性。在设计和实现多线程程序时，需要仔细考虑和分析线程安全性问题，并采取适当的同步机制来确保安全性。尽管C++提供了多线程支持，但并发编程仍然具有一定的复杂性和挑战。正确地处理线程同步、线程间通信和数据共享是确保多线程程序正确运行的关键。
详解Java多线程处理List数据
08-26
主要介绍了Java多线程处理List数据，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
线程导入大数据入库_MySql 快速插入千万级大数据的方法示例
weixin_39860349的博客
01-14 560
在数据分析领域，数据库是我们的好帮手。不仅可以接受我们的查询时间，还可以在这基础上做进一步分析。所以，我们必然要在数据库插入数据。在实际应用中，我们经常遇到千万级，甚至更大的数据量。如果没有一个快速的插入方法，则会事倍功半，花费大量的时间。在参加阿里的天池大数据算法竞赛中(流行音乐趋势预测)，我遇到了这样的问题，在没有优化数据库查询及插入之前，我花了不少冤枉时间，没有优化之前，1500万条数据，光...
多线程实现一分钟插入1000万条数据
热门推荐
weixin_42324471的博客
08-14 2万+
  首先我们需要建立一个线程类，继承Thread类，并实现run方法    1、获取数据库连接    2、编写插入的sql语句    3、关闭自动提交  conn.setAutoCommit(false);    4、编写for循环，跟着那个的插入方法一样。     5、将注入的信息，一条条添加到pst中。pst.addBatch();//批量添加信息    6、在for循环结束的地方...
随记百万级数据读取并处理（java批量插入，多线程处理，并行流查询）
weixin_45475063的博客
05-28 7039
一. 将数据入库 在Linux中将文件进行拆分：split -a 2 -l 1000000 -d test.csv file_ （百万切割csv文件） 将文件复制到本地进行解析 采用策略使用 java.sql.PreparedStatement 批处理数据（启用事务） 批处理：数据库处理速度极快，单次吞吐量很大，执行效率高，addBatch()将sql装载在一起，一次性送往数据库执行 // 构建连接 private Connection getConnection() throws Exce
java多线程处理百万数据
weixin_44039105的博客
08-11 6178
java实现多线程处理数据
多线程的方式的将100万条数据，从一个数据库迁移到另一个数据库
qq_25520483的博客
03-22 1452
多线程的方式的将100万条数据，从一个数据库迁移到另一个数据库。
java 批量插入千万条数据优化方案【值得收藏】
javaXingzhe的博客
03-01 7547
java 千万条数据插入mysql优化
C#多线程中的异常处理操作示例
12-25
本文实例讲述了C#多线程中的异常处理操作。分享给大家供大家参考，具体如下： 常规Thread中处理异常 使用Thread创建的子线程,需要在委托中捕捉,无法在上下文线程中捕捉 static void Main(string[] args) { Thread...
C#多线程处理多个队列数据的方法
09-03
主要介绍了C#多线程处理多个队列数据的方法,涉及C#线程与队列的相关操作技巧,需要的朋友可以参考下
CountDownLatch实战应用——批量数据多线程协调异步处理(主线程执行事务回滚)
一恍过去
11-26 4748
CountDownLatch实战应用——批量数据多线程协调异步处理(主线程执行事务回滚)
java用多线程批次查询大量数据（Callable返回数据）方式
hi_tomorrow的博客
04-12 4801
我看到有的数据库是一万条数据和八万条数据还有十几万条，几百万的数据，然后我就想拿这些数据测试一下，发现如果用java和数据库查询就连一万多条的数据查询出来就要10s左右，感觉太慢了。然后网上都说各种加索引，加索引貌似是有查询条件时在某个字段加索引比较快一些，但是毕竟是人家的库不能瞎动，再者说了，数据量偏大一点的，条件加上也还有好多数据怎么办，我想到了多线程的方式，话不多说，开始弄 多线程有好几种...
使用多线程查询大量数据信息
Sir.He的博客
08-16 3751
使用多线程查询大量数据信息 1、创建一个线程池： public class ThreadPoolExecutorFactory { public static final ExecutorService executor = Executors.newFixedThreadPool(20); } 2、创建一个CountDownLatch计数器闭锁，通过它可以完成类似于阻塞当前线程的...
java中多线程去跑海量数据线程池批量ThreadPoolExecutor处理的方式具体实现步骤实例？
gb4215287的博客
09-03 534
java中多线程去跑海量数据线程池批量ThreadPoolExecutor处理的方式具体实现步骤实例？
java使用线程求素数和1000个0～0.9随机数_多线程实现求1到1000000的质数
weixin_29326909的博客
02-26 206
package datastrucates.arrays.newprimenumber;import java.util.ArrayList;import java.util.List;import java.util.concurrent.Callable;import java.util.concurrent.ExecutorService;import java.util.concurren...
java 多线程处理千万数据_千万数据积压，用Spring快速封装多线程，处理效率的确很高...
weixin_42500625的博客
02-28 1308
工作中常常会出现，数据处理积压的情况，这个时候就会用到多线程，提高并发处理任务的能力。线程是进程中执行运算的最小单位，进程是表示资源分配的基本单位，多线程代表一个程序进程下通过程序控制开启多个线程任务类。java的jdk中已经分装好了多线程模块，实现多线程的方式有两种，一种是通过继承 Thread 类，另一种是通过实现 Runnable 接口。使用继承 Thread 类创建多线程，最大的缺点就是不...
多线程读取mongodb千万级数据
05-15
MongoDB是一种NoSQL数据库，它可以在存储千万甚至亿级数据时提供高效的读写性能。实现多线程读取 MongoDB 千万级数据的关键在于高效地利用系统资源，减少IO等待和CPU的瓶颈。 首先，多线程读取 MongoDB 数据需要使用适当的驱动程序和线程池来实现。线程池可以预先分配一定数量的线程，在多个任务并发时，避免了创建和销毁线程的开销，可以节省系统资源和提高执行速度。 其次，在读取 MongoDB 数据时，可以使用合适的数据分片技术，把数据分为多个块进行读取，以增加数据读取速度。此外，可以使用 MongoDB的复制集功能，将数据复制到多个服务器上，以提高可用性和读取性能。 最后，为了能够并行读取多个document，需要将这些document分割成块，每个线程都有一个块，线程之间能够并行工作。同时，也可以考虑调整缓存大小，减少读取磁盘的次数，从而提高读取速度。 因此，综合运用上述技术，可以实现高效的多线程读取 MongoDB 千万级数据。同时，还需注意线程的同步，避免数据读取的并发冲突问题，确保数据的一致性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值