public class Tasker implements Runnable {

    private String url;
    private CyclicBarrier threadStartBarrier;
    private CountDownLatch threadEndLatch;
    private int count;
    private List<Long> everyTimes;

    @Override
    public void run() {
        try {
            this.threadStartBarrier.await();
            for(int i = 0; i < this.count; ++i) {
                long start = System.currentTimeMillis();
                HttpURLConnection urlConnection = null;
                try {
                    final URL link = new URL(url);
                    urlConnection = (HttpURLConnection) link.openConnection();
                    urlConnection.setRequestMethod("GET");
                    InputStream response = urlConnection.getInputStream();
                    response.close();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (urlConnection != null) {
                        urlConnection.disconnect();
                    }
                    long end = System.currentTimeMillis();
                    long limit = end - start;
                    System.out.println("线程【" + Thread.currentThread().getName()+  "】本次请求耗时【" + limit + "】");
                    this.everyTimes.add(limit);
                }
            }

            this.threadEndLatch.countDown();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 构造函数
     * @param url
     * @param threadStartBarrier
     * @param threadEndLatch
     * @param count
     */
    public Tasker(String url, CyclicBarrier threadStartBarrier, CountDownLatch threadEndLatch, int count) {
        this.url = url;
        this.threadStartBarrier = threadStartBarrier;
        this.threadEndLatch = threadEndLatch;
        this.count = count;
        this.everyTimes = new ArrayList<>(count);
    }


    /**
     * 获取本次任务所有请求的响应时间集合
     * @return
     */
    public List<Long> getEveryTimes() {
        return this.everyTimes;
    }
}

public class StressResult {
    private int concurrencyNum;
    private int totalRequest;
    private double avgTime;
    private long responseTimeOfPercent95;

    public int getConcurrencyNum() {
        return concurrencyNum;
    }

    public void setConcurrencyNum(int concurrencyNum) {
        this.concurrencyNum = concurrencyNum;
    }

    public int getTotalRequest() {
        return totalRequest;
    }

    public void setTotalRequest(int totalRequest) {
        this.totalRequest = totalRequest;
    }

    public double getAvgTime() {
        return avgTime;
    }

    public void setAvgTime(double avgTime) {
        this.avgTime = avgTime;
    }

    public long getResponseTimeOfPercent95() {
        return responseTimeOfPercent95;
    }

    public void setResponseTimeOfPercent95(long responseTimeOfPercent95) {
        this.responseTimeOfPercent95 = responseTimeOfPercent95;
    }

    @Override
    public String toString() {
        return "StressResult{" +
                "并发数 = " + concurrencyNum +
                ", 总请求数 = " + totalRequest +
                ", 平均响应时长 = " + avgTime +
                ", 95%响应时长 = " + responseTimeOfPercent95 +
                '}';
    }

public class StressTasker {

    //自定义线程名
    private ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
            .setNameFormat("stress-thread-%d").build();

    /**
     * 压测任务
     * @param concurrencyLevel
     * @param totalRequests
     * @param url
     * @return
     */
    public StressResult doWork(int concurrencyLevel, int totalRequests, String url) {
        //计算每个线程请求多少次
        int everyThreadCount = totalRequests / concurrencyLevel;
        //设置辅助类线程，用于结果统计，栅栏等待所有线程运行完成
        CyclicBarrier threadStartBarrier = new CyclicBarrier(concurrencyLevel);
        // 计数使用，所有子线程任务执行完才视为完全结束，保证所有都完成
        CountDownLatch threadEndLatch = new CountDownLatch(concurrencyLevel);
        //创建线程池
        ExecutorService executorService = new ThreadPoolExecutor(concurrencyLevel, concurrencyLevel * 2, 0L,
                TimeUnit.MILLISECONDS, new SynchronousQueue<>(),
                namedThreadFactory, new ThreadPoolExecutor.CallerRunsPolicy());
        List<Tasker> taskers = new ArrayList<>(concurrencyLevel);

        int realTotalRequests;
        Tasker tasker;
        // 添加工作任务
        for (realTotalRequests = 0; realTotalRequests < concurrencyLevel; ++realTotalRequests) {
            tasker = new Tasker(url, threadStartBarrier, threadEndLatch, everyThreadCount);
            taskers.add(tasker);
        }
        // 提交任务
        for (realTotalRequests = 0; realTotalRequests < concurrencyLevel; ++realTotalRequests) {
            tasker = taskers.get(realTotalRequests);
            executorService.submit(tasker);
        }

        try {
            threadEndLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 关闭线程
        executorService.shutdownNow();
        realTotalRequests = everyThreadCount * concurrencyLevel;
        System.out.println("真实处理线程数量 = " + realTotalRequests);

        // 执行结果
        StressResult stressResult = this.getStressResult(taskers);
        stressResult.setConcurrencyNum(concurrencyLevel);
        stressResult.setTotalRequest(totalRequests);
        return stressResult;
    }


    /**
     * 压测结果处理
     * @param taskers
     * @return
     */
    protected StressResult getStressResult(List<Tasker> taskers) {
        StressResult result = new StressResult();
        List<Long> allTimes = new ArrayList<>();
        for (Tasker tasker : taskers) {
            List<Long> everyTaskerTimes = tasker.getEveryTimes();
            allTimes.addAll(everyTaskerTimes);
        }
        System.out.println("所有请求响应时间：" + JSON.toJSONString(allTimes));
        double avgTime = allTimes.stream().mapToLong(Long::longValue).average().getAsDouble();
        result.setAvgTime(avgTime);

        Collections.sort(allTimes);
        int index = (int) Math.ceil(95 / 100.0 * allTimes.size());
        result.setResponseTimeOfPercent95(allTimes.get(index - 1));
        return result;
    }


}

    @Test
    public void test(){
        StressTasker tasker = new StressTasker();
        StressResult result = tasker.doWork(10,100,"http://www.baidu.com");
        System.out.println(result.toString());
    }