一棵树～

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

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  List> avgList(List source, int n) {
	    List> result = new ArrayList<>();
		//(先计算出余数)
	    int remainder = source.size() % n;  
	    //然后是商
	    int number = source.size() / n;  
		//偏移量
	    int offset = 0;
	    for (int i = 0; i < n; i++) {
	        List 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  List> splitList(List resList, int count) {  
        if (resList == null || count < 1) {
        	return null;  
        }
       
        //long t1 = System.currentTimeMillis();
        List> result = new ArrayList>();  
        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 itemList = new ArrayList();  
                for (int j = 0; j < count; j++) {  
                    itemList.add(resList.get(i * count + j));  
                }  
                result.add(itemList);  
            }  
            // last的进行处理  
            if (last > 0) {  
                List itemList = new ArrayList();  
                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  List> splitList2(List list, int count) { //效率低不推荐使用
		long t1 = System.currentTimeMillis();
		int limit = (list.size() + count - 1) / count;
		// 方法一：使用流遍历操作
		/*List> 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> 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 list=new ArrayList<>();
		for (int i = 0; i < 17; i++) {
			list.add(i);
		}
		List> avgList = avgList(list, 5);
		System.out.println("avgList: " + avgList);
		
		List> splitList = splitList(list, 5);
		System.out.println("splitList: " + splitList);
		
		ArrayList arr_list = new ArrayList<>();
		for (int i = 0; i < splitList.size(); i++) {
			List 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 listKey = new ArrayList<>();
		for (int i = 0; i < count; i++) {
			listKey.add(114560315500000000L + i);
		}
		ConcurrencyTest concurrencyTest = new ConcurrencyTest();
                List 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 getValueList1(List listKey) {
		
		/**
		（1）newCachedThreadPool		创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
    	        （2）newFixedThreadPool 		创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
    	        （3）newScheduledThreadPool	创建一个定长线程池，支持定时及周期性任务执行。
    	        （4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
    	         */
		//创建一个线程池
		final ExecutorService executorService = Executors.newFixedThreadPool(10); //用于控制同时并发执行的线程数，使用线程池创建资源提高效率
		List list_val = Collections.synchronizedList(new ArrayList<>()); //保证多线程操作的是同一个List
		try {
			long t1 = System.currentTimeMillis();
			int max_one_batch = 100000; // 一批次最多处理100000条数据
			List> 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 subList = newList.get(i);
							List 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 getValue(List 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 listKey = new ArrayList<>();
		for (int i = 0; i < count; i++) {
			listKey.add(114560315500000000L + i);
		}
		ConcurrencyTest concurrencyTest = new ConcurrencyTest();
		List 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 getValueList2(List listKey) {
		
		/**
		（1）newCachedThreadPool		创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
    	        （2）newFixedThreadPool 		创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
    	        （3）newScheduledThreadPool	创建一个定长线程池，支持定时及周期性任务执行。
    	        （4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
    	         */
		//创建一个线程池
		final ExecutorService executorService = Executors.newFixedThreadPool(10); //用于控制同时并发执行的线程数，使用线程池创建资源提高效率
		List list_val = Collections.synchronizedList(new ArrayList<>()); //保证多线程操作的是同一个List
		try {
			long t1 = System.currentTimeMillis();
			int threadCount = 100; //请求的线程数
			List> 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 subList = newList.get(i);
							List 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 getValue(List 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

你可能感兴趣的:(【Java-并发编程】)

【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
Java-网络胡净 java 网络开发语言
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。1.网络协议Java支持多种网络协议，最常用的包括：TCP（传输控制协议）：面向连接的协议，确保数据的可靠传输。UDP（用户数据报协议）：无连接的协议，适用于对速度要求高但对可靠性要求低的应用。网络通信模型通常指的是OSI（开放系统互联）模型，它将网络通信分为七个层次。每一层
Java并发编程-AQS详解及案例实战（上篇）猿与禅 Java技术栈源码分析 java AQS 并发编程原理
文章目录AQS概述AQS的核心概念AQS的工作原理AQS的灵活性使用场景使用指南使用示例AQS的本质:为啥叫做异步队列同步器AQS的核心机制“异步队列”的含义“同步器”的含义总结加锁失败的时候如何借助AQS异步入队阻塞等待AQS的锁队列加锁失败时的处理流程异步入队的机制总结ReentractLock如何设置公平锁策略以及原理设置公平锁策略公平锁的运作原理尝试获取锁释放锁性能与公平性的权衡tryLo
Java高并发编程详解系列-深入理解Thread构造 nihui123 高并发 Java高并发 Java 高并发
上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
Java高并发编程详解系列-Balking设计模式 nihui123 高并发设计模式 java 编程语言
导语在实际操作中当某个线程因为发现其他线程正在进行相同的工作而放弃即将开始的任务，这种情况就被称为是Balking模式，Balking英文的意思是犹豫。在多个线程监控某个共享变量，A线程监控到共享变量发生变化后立即触发某个动作，但是这个这个时候发现了B线程也对该变量开始了行动，这个时候A变量就放弃了准备工作。下面就来详细的讲解一下关于Balking模式什么是Balking模式在餐厅吃饭的时
Java高并发编程详解系列-Future设计模式 nihui123 高并发 Java高并发 Future 高并发
导语假设，在一个使用场景中有一个任务需要执行比较长的时间，通常需要等待任务执行结束之后或者是中途出错之后才能返回结果。在这个期间调用者只能等待，对于这个结果Future设计模式提供了一种凭据式的解决方案。在日常生活中，这种方案也是存在的。例如去洗衣店洗衣服，当你把衣服放到洗衣店，等他洗完需要一段时间，这个时候洗衣店就会给你一凭证，你可以通过这个凭证到时候去取洗好的衣服。这个例子就是生活中的Fu
Java 并发编程：Java 线程池的介绍与使用栗筝i 栗筝i 的 Java 技术栈 #Java 基础栗筝i 的 Java 技术栈 Java基础 Java 并发 Java 线程池
大家好，我是栗筝i，这篇文章是我的“栗筝i的Java技术栈”专栏的第024篇文章，在“栗筝i的Java技术栈”这个专栏中我会持续为大家更新Java技术相关全套技术栈内容。专栏的主要目标是已经有一定Java开发经验，并希望进一步完善自己对整个Java技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同
Python 课程8-多线程编程和多进程编程可愛小吉 Python教學 python 开发语言 threading multiprocessing
前言在现代编程中，处理并发任务是提高程序性能的关键之一。Python提供了多线程（threading）和多进程（multiprocessing）两种方式来实现并发编程。多线程适用于I/O密集型任务，而多进程则更适合CPU密集型任务。通过这两种技术，你可以高效地处理大规模数据、加速程序执行并优化资源利用。在本篇详细教程中，我们将讨论如何使用Python的threading模块实现多线程，以及如何使用
Java-后端程序员个人知识总结金肴羽 java 开发语言
文章目录概要1.编程语言2.数据结构与算法3.数据库知识4.框架和库5.服务器管理6.网络知识7.版本控制8.测试9.安全知识10.系统设计11.编码规范与最佳实践12.持续学习和适应能力概要后端程序员，主要负责应用程序的逻辑、数据库交互、服务器配置以及应用的性能优化等。成为一名优秀的后台程序员，需要掌握以下技能：1.编程语言掌握至少一种后台编程语言JavaPythonHtmlJavaScript
Java并发复习 vd_vd Java并发安全容器 java 开发语言
Java基础1.为什么要使用并发编程？一般我们工作的电脑都有多核，我们创建多个线程，然后操作系统可以将多个线程分配给不同的CPU去执行，每个CPU执行一个线程，这样就提高了CPU使用效率。在网络购物中，我们买了一个东西的同时，需要减库存，生成订单等等这些操作，就可以进行拆分利用多线程的技术完成。面对复杂业务模型，并行程序串行会比程序更适应业务需求，而并发编程更能吻合这种业务拆分。->充分利用多核C
多线程的使用--＞5：并发编程的特性路ZP java 开发语言
目录1.并发编程特性：2.并发编程的特性之一：原子性3.并发编程的特性之一：可见性3.1JVM内存模型3.2JMM（Java内存模型）4.并发编程的特性之一：有序性1.并发编程特性：多线程是一种程序开发或设计环境并发编程是一种程序设计概念或设计目标，在多线程开发环境中，同一系列的程序设计与机制的使用，确保多线程开发环境是稳定的，快速的，性能优秀的。并发编程具有3个特征原子性可见性有序性在多线程开发
【Python系列】异步任务的终止 Kwan的解忧杂货铺@新空间代码工作室 s2 Python python 开发语言
欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,Git,
浅谈C#之线程锁 CN.LG C#jvm 开发语言 c#
一、基本介绍锁是一种同步机制，用于控制多个线程对共享资源的访问。当一个线程获得了锁时，其他线程将被阻塞，直到该线程释放了锁。在并发编程中，多个线程同时访问共享资源可能导致数据竞争和不确定的行为。锁可以确保在任意时刻只有一个线程可以访问共享资源，从而避免竞态条件和数据不一致性问题。二、锁的作用原理锁的作用原理通常涉及到内部的互斥机制。当一个线程获得锁时，它会将锁标记为已被占用，其他线程尝试获取该锁时
【Python系列】使用切片移动元素位置 Kwan的解忧杂货铺@新空间代码工作室 s2 Python python 开发语言
欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,Git,
Java 入门指南：Java 并发编程 —— 同步工具类 Semephore（信号量） ZachOn1y Java java 开发语言 intellij-idea 个人开发团队开发 java-ee
文章目录同步工具类Semephore核心功能限制并发访问量公平与非公平策略灵活性与适应性常用方法使用示例同步工具类JUC（Java.util.concurrent）是Java提供的用于并发编程的工具类库，其中包含了一些通信工具类，用于在多个线程之间进行协调和通信，特别是在多线程和网络通信方面。这些工具类提供了丰富的功能，帮助开发者高效地实现复杂的并发控制和网络通信需求。SemephoreSemap
Java 入门指南：Java 并发编程 —— 同步工具类 CountDownLatch（倒计时门闩） ZachOn1y Java java 后端个人开发 java-ee 团队开发
文章目录同步工具类CountDownLatch常用方法使用步骤适用场景使用示例同步工具类JUC（Java.util.concurrent）是Java提供的用于并发编程的工具类库，其中包含了一些通信工具类，用于在多个线程之间进行协调和通信，特别是在多线程和网络通信方面。这些工具类提供了丰富的功能，帮助开发者高效地实现复杂的并发控制和网络通信需求。CountDownLatchCountDownLatc
锁之synchronized 与volatile lock的异同追梦的鱼儿 java 锁 synchronized volatile Lock
目录synchronized特性用法使用场景synchronized的优缺点优点缺点volatile特性用法使用场景Lock特性用法使用场景总结相同点不同点synchronized关键字是Java提供的用于解决并发编程中数据一致性问题的重要工具。它通过锁机制确保在同一时刻只有一个线程能够执行被同步的方法或代码块，从而实现互斥访问。尽管synchronized使用简单且可靠，但在高并发场景下可能会带
Go Web 编程 PDF book_longker 资源 golang pdf 开发语言
GoWeb开发必读:《BuildingWebApplicationswithGo》PDF资源分享找寻良久,终于寻得这本珍贵资源!现在我免费分享给大家你是否正在学习Go语言开发Web应用?是否想要提升Go并发编程能力?这本书绝对不容错过!关于这本书《BuildingWebApplicationswithGo》是一本非常实用的GoWeb开发指南:以构建网络论坛为案例,全面讲解GoWeb开发️深入剖析请
Java-实现双向环形链表 Bro_cat 数据结构与算法链表数据结构 java 双向环形链表
双向链表是一种常用的数据结构，其特点是每个节点不仅包含数据，还持有指向前一个节点和后一个节点的指针。与普通双向链表不同的是，它的哨兵节点的prev指向最后一个元素，而最后一个元素的next指向哨兵。具体双向普通链表可以参考我的上篇文章，这里是传送门。什么是双向环形链表？双向环形链表不仅支持双向遍历，还形成一个闭合环，即最后一个节点的next指针指向链表的头部，第一个节点的prev指针指向链表的尾部
Java并发编程：线程生命周期乐只乐之 Java并发编程 java 职场和发展后端
Java并发编程专栏文章收录于Java并发编程专栏线程生命周期线程是Java并发编程的核心概念，理解线程生命周期对于编写高效的并发程序至关重要。本文将详细介绍Java线程的六种状态以及状态之间的转换关系，帮助读者更好地理解线程的行为。在Java中JVM将线程按照生命周期划分为了四大种类：运行、等待、阻塞和结束，其中运行分为就绪（READY）和运行中中（RUNNING），阻塞分为等待（WAI
JAVA中的线程池说明一 Petrichor-瑾 JavaEE java 开发语言
系列文章JAVA中的线程池说明一JAVA中的线程池说明二目录1.为什么需要线程池?2.什么是线程池?3.标准库中的线程池4.实现自定义线程池1.为什么需要线程池?线程的存在意义在于解决并发编程中进程开销过大的问题，因此引入了线程，也被称为"轻量级线程"。相比于创建进程，创建线程更加高效；同样地，销毁线程比销毁进程更高效，调度线程比调度进程更高效。在许多情况下，使用多线程可以替代进程来实现并发编程。
Java多线程：深入探索与详细解析 m0_63550220 java 开发语言
1.基础概念与重要性在Java编程中，多线程是并发编程的基石，它允许应用程序同时执行多个任务。这种能力不仅提高了程序的执行效率，还增强了其响应性和用户界面的流畅性。随着现代计算机系统的多核化趋势，多线程编程变得越来越重要，因为它能够充分利用硬件资源，提升程序的总体性能。线程（Thread）：作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线
Maven项目结构说明 HachiLin SpringBoot maven springboot 微服务
1.maven概念是一个基于Java平台的自动化构建工具（make->ant->maven->gradle，它主要有五大功能：（1）清理：删除编译的结果，为重新编译做准备（2）编译：java->class（3）测试：针对与项目中的关键点进行测试，方便开发人员与测试人员交互（4）报告：将测试结果进行显示（5）打包：将项目中包含的多个文件压缩成一个文件，用于安装或部署（java项目打成jar包，web
【Python系列】中位数计算 Kwan的解忧杂货铺@新空间代码工作室 s2 Python python 开发语言
欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术,jvm,并发编程redis,kafka,Spring,微服务等常用开发工具系列:常用的开发工具,IDEA,Mac,Alfred,Git,
模式转变-并行编程方面的设计注意事项 guoxiaoqian8028 并行计算
本文以VisualStudio工具的预发布版为基础。文中的所有信息均有可能发生变更。本文将介绍以下内容：并行计算并发编程性能提高本文使用了以下技术：多线程目录并发和并行结构化多线程数据并行性数据流数据并行性单程序，多数据并发数据结构总结从1986到2002年，微处理器的性能每年提高了52%。这一惊人的技术进步源自晶体管成本依据摩尔法则不断地缩减，以及处理器厂商在工程方面的出色表现。微软的研究员Ji
函数式编程-Stream流码农OvO 开发语言 java
函数式编程-Stream流1.概述1.1好处大数量下处理集合效率高代码可读性高消灭嵌套1.2函数式编程思想1.2.1概念面向对象思想需要关注用什么对象完成什么事情。而函数式编程思想就类似于我们数学中的函数。它主要关注的是对数据进行了什么操作。1.2.2优点代码简洁接近自然语言，易于理解易于"并发编程"2.Lambda表达式2.1概述Lambda是Jdk8中的一个语法糖。它可以对某些匿名内部类的写法
SpringBoot高并发！java分布式开发面试题 spring面试题程序员面试后端 java
正文梳理知识点，是快速提升技术的关键前面讲过，快速提升自己的技术硬实力其实是有方法的。大致就是梳理知识点+夯实基础+进阶深入学习+实战，下面我会一点点跟大家剖析，本文干货满满，大家仔细阅读。梳理知识后，夯实基础乃是刚需：深入进阶学习（28个主流Java知识点“一网打尽”）1、并发编程Java并发编程是整个Java开发体系中最难以理解，但也是最重要的知识点之一，一旦掌握你一定在市场上供不应求。Jav
Java并发编程(五)—ReetrantLock详解及应用 echola_mendes Java并发编程 java 开发语言
目录一、ReetrantLock的特性1、非阻塞获取锁2、带超时的锁获取:3、锁的公平性4、锁的可中断性5、Condition条件变量6、锁的可重入性可重入锁不可重入锁7、性能优化二、ReentrantLock和Synchronized的区别1、语法和使用方式2、锁的获取和释放3、高级特性4、条件变量5、性能总结三、ReentrantLock使用场景之前的文章Java并发编程(四)—synchro
并发编程——线程的启动不太自律的程序猿
前言今天简单的讲一讲线程的启动start方法。如果对于线程的创建方式不太了解，推荐观看并发编程——认识java里的线程对于线程状态及其切换不了解的，推荐观看并发编程——Java线程的6种状态及切换线程的启动在并发编程——认识java里的线程中我们有讲过线程的创建，我们启动线程的时候使用的是start方法。那么我们就先来看看start方法，简单的附上一些源码：关于threadStatus源码：通过代
《代码整洁之道》读书笔记 fsy351 java 开发语言
《代码整洁之道》读书笔记根据书名，可以知道这本书围绕“代码整洁”的思想和方法展开，但是个人认为，它不仅仅强调了代码整洁内容，更多的还包括代码测试、系统设计、并发编程的部分内容。全书共分为17个章节和2个附加章节。整本书的章节感觉编排有点杂乱，根据个人理解整理成如下结构图：概念整洁代码为何要有整洁代码？代码确然是我们最终用来表达需求的语言，代码永存糟糕的代码会毁灭一家公司PS：当前信息时代，软件是生
用MiddleGenIDE工具生成hibernate的POJO（根据数据表生成POJO类） AdyZhang POJO eclipse Hibernate MiddleGenIDE
推荐:MiddlegenIDE插件, 是一个Eclipse 插件. 用它可以直接连接到数据库, 根据表按照一定的HIBERNATE规则作出BEAN和对应的XML ，用完后你可以手动删除它加载的JAR包和XML文件! 今天开始试着使用
.9.png Cb123456 android
“点九”是andriod平台的应用软件开发里的一种特殊的图片形式，文件扩展名为：.9.png 　　智能手机中有自动横屏的功能,同一幅界面会在随着手机(或平板电脑)中的方向传感器的参数不同而改变显示的方向,在界面改变方向后,界面上的图形会因为长宽的变化而产生拉伸,造成图形的失真变形。　　我们都知道android平台有多种不同的分辨率，很多控件的切图文件在被放大拉伸后，边
算法的效率天子之骄算法效率复杂度最坏情况运行时间大O阶平均情况运行时间
算法的效率效率是速度和空间消耗的度量。集中考虑程序的速度，也称运行时间或执行时间，用复杂度的阶(O)这一标准来衡量。空间的消耗或需求也可以用大O表示，而且它总是小于或等于时间需求。以下是我的学习笔记： 1.求值与霍纳法则，即为秦九韶公式。 2.测定运行时间的最可靠方法是计数对运行时间有贡献的基本操作的执行次数。运行时间与这个计数成正比。
java数据结构何必如此 java 数据结构
Java 数据结构 Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：枚举（Enumeration）位集合（BitSet）向量（Vector）栈（Stack）字典（Dictionary）哈希表（Hashtable）属性（Properties）以上这些类是传统遗留的，在Java2中引入了一种新的框架-集合框架(Collect
MybatisHelloWorld 3213213333332132
//测试入口TestMyBatis package com.base.helloworld.test; import java.io.IOException; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibat
Java|urlrewrite|URL重写|多个参数 7454103 java xml Web 工作
个人工作经验！如有不当之处，敬请指点 1.0 web -info 目录下建立 urlrewrite.xml 文件类似如下： <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE u
达梦数据库+ibatis darkranger sql mysql ibatis SQL Server
--插入数据方面如果您需要数据库自增... 那么在插入的时候不需要指定自增列. 如果想自己指定ID列的值, 那么要设置 set identity_insert 数据库名.模式名.表名; ----然后插入数据; example: create table zhabei.test( id bigint identity(1,1) primary key, nam
XML 解析四种方式 aijuans android
XML现在已经成为一种通用的数据交换格式,平台的无关性使得很多场合都需要用到XML。本文将详细介绍用Java解析XML的四种方法。 XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object
spring中配置文件占位符的使用 avords
1.类 <?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.o
前端工程化-公共模块的依赖和常用的工作流 bee1314 webpack
题记：一个人的项目，还有工程化的问题嘛？我们在推进模块化和组件化的过程中，肯定会不断的沉淀出我们项目的模块和组件。对于这些沉淀出的模块和组件怎么管理？另外怎么依赖也是个问题？你真的想这样嘛？ var BreadCrumb = require(‘../../../../uikit/breadcrumb’); //真心ugly。
上司说「看你每天准时下班就知道你工作量不饱和」，该如何回应？ bijian1013 项目管理沟通 IT职业规划
问题：上司说「看你每天准时下班就知道你工作量不饱和」，如何回应正常下班时间6点，只要是6点半前下班的，上司都认为没有加班。 Eno-Bea回答，注重感受，不一定是别人的虽然我不知道你具体从事什么工作与职业，但是我大概猜测，你是从事一项不太容易出现阶段性成果的工作
TortoiseSVN，过滤文件征客丶 SVN
环境： TortoiseSVN 1.8 配置：在文件夹空白处右键选择 TortoiseSVN -> Settings 在 Global ignote pattern 中添加要过滤的文件：多类型用英文空格分开 *name ：过滤所有名称为 name 的文件或文件夹 *.name ：过滤所有后缀为 name 的文件或文件夹 --------
【Flume二】HDFS sink细说 bit1129 Flume
1. Flume配置 a1.sources=r1 a1.channels=c1 a1.sinks=k1 ###Flume负责启动44444端口 a1.sources.r1.type=avro a1.sources.r1.bind=0.0.0.0 a1.sources.r1.port=44444 a1.sources.r1.chan
The Eight Myths of Erlang Performance bookjovi erlang
erlang有一篇guide很有意思： http://www.erlang.org/doc/efficiency_guide 里面有个The Eight Myths of Erlang Performance： http://www.erlang.org/doc/efficiency_guide/myths.html Myth: Funs are sl
java多线程网络传输文件(非同步)-2008-08-17 ljy325 java 多线程 socket
利用 Socket 套接字进行面向连接通信的编程。客户端读取本地文件并发送；服务器接收文件并保存到本地文件系统中。使用说明:请将TransferClient, TransferServer, TempFile三个类编译，他们的类包是FileServer. 客户端: 修改TransferClient: serPort, serIP, filePath, blockNum,的值来符合您机器的系
读《研磨设计模式》-代码笔记-模板方法模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet;
配置心得 chenyu19891124 配置
时间就这样不知不觉的走过了一个春夏秋冬，转眼间来公司已经一年了，感觉时间过的很快，时间老人总是这样不停走，从来没停歇过。作为一名新手的配置管理员，刚开始真的是对配置管理是一点不懂，就只听说咱们公司配置主要是负责升级，而具体该怎么做却一点都不了解。经过老员工的一点点讲解，慢慢的对配置有了初步了解，对自己所在的岗位也慢慢的了解。做了一年的配置管理给自总结下： 1.改变从一个以前对配置毫无
对“带条件选择的并行汇聚路由问题”的再思考 comsci 算法工作软件测试嵌入式领域模型
2008年上半年，我在设计并开发基于”JWFD流程系统“的商业化改进型引擎的时候，由于采用了新的嵌入式公式模块而导致出现“带条件选择的并行汇聚路由问题”(请参考2009-02-27博文)，当时对这个问题的解决办法是采用基于拓扑结构的处理思想，对汇聚点的实际前驱分支节点通过算法预测出来，然后进行处理，简单的说就是找到造成这个汇聚模型的分支起点，对这个起始分支节点实际走的路径数进行计算，然后把这个实际
Oracle 10g 的clusterware 32位下载地址 daizj oracle
Oracle 10g 的clusterware 32位下载地址 http://pan.baidu.com/share/link?shareid=531580&uk=421021908 http://pan.baidu.com/share/link?shareid=137223&uk=321552738 http://pan.baidu.com/share/l
非常好的介绍：Linux定时执行工具cron dongwei_6688 linux
Linux经过十多年的发展，很多用户都很了解Linux了，这里介绍一下Linux下cron的理解，和大家讨论讨论。cron是一个Linux 定时执行工具，可以在无需人工干预的情况下运行作业，本文档不讲cron实现原理，主要讲一下Linux定时执行工具cron的具体使用及简单介绍。新增调度任务推荐使用crontab -e命令添加自定义的任务（编辑的是/var/spool/cron下对应用户的cr
Yii assets目录生成及修改 dcj3sjt126com yii
assets的作用是方便模块化，插件化的，一般来说出于安全原因不允许通过url访问protected下面的文件，但是我们又希望将module单独出来，所以需要使用发布，即将一个目录下的文件复制一份到assets下面方便通过url访问。 assets设置对应的方法位置 \framework\web\CAssetManager.php assets配置方法在m
mac工作软件推荐 dcj3sjt126com mac
mac上的Terminal + bash ＋ screen组合现在已经非常好用了，但是还是经不起iterm＋zsh＋tmux的冲击。在同事的强烈推荐下，趁着升级mac系统的机会，顺便也切换到iterm＋zsh＋tmux的环境下了。我为什么要要iterm2 切换过来也是脑袋一热的冲动，我也调查过一些资料，看了下iterm的一些优点： * 兼容性好，远程服务器 vi 什么的低版本能很好兼
Memcached(三)、封装Memcached和Ehcache frank1234 memcached ehcache spring ioc
本文对Ehcache和Memcached进行了简单的封装，这样对于客户端程序无需了解ehcache和memcached的差异，仅需要配置缓存的Provider类就可以在二者之间进行切换，Provider实现类通过Spring IoC注入。 cache.xml <?xml version="1.0" encoding="UTF-8"?>
Remove Duplicates from Sorted List II hcx2013 remove
Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. For example,Given 1->2->3->3->4->4->5,
Spring4新特性——注解、脚本、任务、MVC等其他特性改进 jinnianshilongnian spring4
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
MySQL安装文档 liyong0802 mysql
工作中用到的MySQL可能安装在两种操作系统中，即Windows系统和Linux系统。以Linux系统中情况居多。安装在Windows系统时与其它Windows应用程序相同按照安装向导一直下一步就即，这里就不具体介绍，本文档只介绍Linux系统下MySQL的安装步骤。 Linux系统下安装MySQL分为三种：RPM包安装、二进制包安装和源码包安装。二
使用VS2010构建HotSpot工程 p2p2500 HotSpot OpenJDK VS2010
1. 下载OpenJDK7的源码： http://download.java.net/openjdk/jdk7 http://download.java.net/openjdk/ 2. 环境配置 ▶
Oracle实用功能之分组后列合并 seandeng888 oracle 分组实用功能合并
1 实例解析由于业务需求需要对表中的数据进行分组后进行合并的处理，鉴于Oracle10g没有现成的函数实现该功能，且该功能如若用JAVA代码实现会比较复杂，因此，特将SQL语言的实现方式分享出来，希望对大家有所帮助。如下：表test 数据如下： ID,SUBJECTCODE,DIMCODE,VALUE 1&nbs
Java定时任务注解方式实现 tuoni java spring jvm xml jni
Spring 注解的定时任务，有如下两种方式：第一种： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http
11大Java开源中文分词器的使用方法和分词效果对比 yangshangchuan word分词器 ansj分词器 Stanford分词器 FudanNLP分词器 HanLP分词器
本文的目标有两个： 1、学会使用11大Java开源中文分词器 2、对比分析11大Java开源中文分词器的分词效果本文给出了11大Java开源中文分词的使用方法以及分词结果对比代码，至于效果哪个好，那要用的人结合自己的应用场景自己来判断。 11大Java开源中文分词器，不同的分词器有不同的用法，定义的接口也不一样，我们先定义一个统一的接口： /** * 获取文本的所有分词结果, 对比