倒计数锁存器（CountDown Latch）和 CyclicBarrier（同步屏障）

 public  static long time(Executor executor,int concurrency,final Runnable action)throws InterruptedException{
        //CountDownLatch 构造器参数代表 只有调用countDown()方法达到这个int值的时候，才能继续（所以多线程的情况下可以在此阻塞）
        final CountDownLatch ready=new CountDownLatch(concurrency);
        final CountDownLatch start=new CountDownLatch(1);
        final CountDownLatch done=new CountDownLatch(concurrency);
        for (int i=0;i<concurrency;i++){
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    ready.countDown();//准备好了一个就++1
                    try{
                        start.await();//等待所有for循环跑完 主线程执行countDown的时候才能继续走
                        action.run();
                    }catch (InterruptedException ex){
                        Thread.currentThread().interrupt();
                    }finally{
                        done.countDown();//线程执行完了才能++
                    }
                }
            });
        }
        ready.await();
        long startNanos=System.nanoTime();
        start.countDown();
        done.await();//阻塞等待异步线程的countDown()调用次数达到阀值
        return  System.nanoTime()-startNanos;
    }

 public static long time1(Executor executor, int concurrency, final Runnable action) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(concurrency);
        long startNanos = System.nanoTime();
        for (int i = 0; i < concurrency; i++) {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        action.run();
                    } finally {
                        try {
                            cyclicBarrier.await();
                        } catch (BrokenBarrierException ex) {

                        } catch (InterruptedException ex) {

                        }
                    }
                }
            });
        }
        return System.nanoTime() - startNanos;
    }