java如何统计多线程高并发下的总执行时间

办法是使用java.util.concurrent包下的计数器工具类CountDownLatch，看demo，本demo巧妙的使用了CountDownLatch让多线程模拟高并发以及所有线程执行完之后的耗时。

    private static Date startDate;
	private static Date endDate;
	private static String startTime;
	private static String endTime;
	/**
	 * 测试memcached高并发,主函数 .
	 * 
	 * @param args
	 */
	public static void main(String args[]) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		memcachedManager = ctx.getBean(MemcachedManager.class);
		startDate=new Date();
		SimpleDateFormat format=new SimpleDateFormat("yyyyMMddHHmmssSSS");
		startTime=format.format(startDate);
		//顺序执行
		//executeOrder();
		//并发执行
		executeConcurrent();
	}
	
	/**
	 * 顺序执行
	 */
	public static void executeOrder()
	{
	    int total=10000;
		for (int a = 0; a < total; a++) {
				try {
					// 顺序执行
					memcachedManager.put("hello" + a, "Hello,xmemcached" + a);
					String value1 = memcachedManager.get("hello" + a);
					System.out.println("第" + a + "个请求,hello" + a + "=" + value1);


				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			endDate=new Date();
			SimpleDateFormat format=new SimpleDateFormat("yyyyMMddHHmmssSSS");
			endTime=format.format(endDate);
			long consumeTime=endDate.getTime()-startDate.getTime();
			
			System.out.println("顺序执行"+total+"次，开始时间:"+startTime+",结束时间"+endTime+",总耗时："+consumeTime+"毫秒");
			

	}
	/**
	 * 高并发执行
	 */
	public static void executeConcurrent()
	{
		int cycleTimes=100;//循环次数
		int concurrentTimes=100;//同时并发次数
		CountDownLatch countDownLatchTotal = new CountDownLatch(cycleTimes*concurrentTimes);
		//循环次数
		for (int m = 0; m < cycleTimes; m++) {
			CountDownLatch countDownLatch = new CountDownLatch(1);
			//并发执行线程个数
			for (int a = 0; a < concurrentTimes; a++) {
				try {
					// 多线程同时执行
					 new Thread(new MyRun(countDownLatchTotal,countDownLatch, a)).start();

				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			// 同时启动多个线程
			countDownLatch.countDown();
		}
		try {
            //在所有线程未执行完，即countDownLatchTotal计数还未到0的情况下会继续等在这里
			countDownLatchTotal.await();
			endDate=new Date();
			SimpleDateFormat format=new SimpleDateFormat("yyyyMMddHHmmssSSS");
			endTime=format.format(endDate);
			long consumeTime=endDate.getTime()-startDate.getTime();
			
			System.out.println("并发执行"+(cycleTimes*concurrentTimes)+"次，开始时间:"+startTime+",结束时间"+endTime+",总耗时："+consumeTime+"毫秒");
			//所以线程执行完了，再计算总耗时
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		

	}
	
	



	/**
	 * 
	 *      * 线程类
	 * 
	 *      
	 */

	public static class MyRun implements Runnable {

		private CountDownLatch countDownLatch;
		private CountDownLatch countDownLatchTotal;
		public int index;

		public MyRun(CountDownLatch countDownLatchTotal,CountDownLatch countDownLatch, int index) {
			this.countDownLatchTotal=countDownLatchTotal;
			this.countDownLatch = countDownLatch;
			this.index = index;
			// threadLocal.set(index);
		}

		@Override
		public void run() {
			try {
				System.out.println("当前等待线程：" + index);
                //计数器未到达0的时候，每个线程都先等在这里
				countDownLatch.await();
				System.out.println("所有线程同时开始执行" + index);
				
				memcachedManager.put("hello" + index, "Hello,xmemcached" + index);
				String value1 = memcachedManager.get("hello" + index);
				System.out.println("当前线程名字：" + Thread.currentThread().getName() + "，第" + index + "个请求,hello" + index
						+ "=" + value1);
				
				//执行完一次计数器减一
				countDownLatchTotal.countDown();

			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();

			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (Error er) {
				er.printStackTrace();

			}

		}

	}