第七周

package com.leopo.capacitytestutils;

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CapacityTestingTool {

    /**
     * URL
     */
    private  String url;

    /**
     * 请求数
     */
    private  int sumRequest;

    /**
     * 线程池
     */
    private  ExecutorService pool;

    public CapacityTestingTool(String url,int sumRequest,ExecutorService pool){
        this.url = url;
        this.sumRequest = sumRequest;
        this.pool = pool;
    }

    /**
     * 执行的核心方法
     * @return
     */
    public double[] run(){
        //用于计数和调度
        CountDownLatch doneSignal = new CountDownLatch(sumRequest);

        //保存每个线程的执行时间，线程安全
        Queue<Long> timeQueue = new ConcurrentLinkedDeque<>();

        /*
         *创建100个线程
         */
        for(int i = 0; i < sumRequest;i++){
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    HttpURLConnection con = null;
                    long startTime = System.currentTimeMillis();
                    try {
                        URL link = new URL(url);
                        con = (HttpURLConnection) link.openConnection();
                        con.setRequestMethod("GET");
                        InputStream response = con.getInputStream();
                        //读流，为了减少测试误差，次数省略读流的操作
                        response.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        if (con != null) {
                            con.disconnect();
                        }
                    }
                    long endTime = System.currentTimeMillis();
                    timeQueue.add(endTime - startTime);
                    doneSignal.countDown();
                }
            });
        }
        try {
            doneSignal.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        /*
         *处理返回平均时间和95%的时间
         */
        List<Long> times = new ArrayList<>(timeQueue);
        double avgResponseTime = getAvg(times) / 1000.0;
        double ninetyFivePercentileTime = get95Percentile(times) / 1000.0;
        return new double[]{avgResponseTime, ninetyFivePercentileTime};
    }

    private static double getAvg(List<Long> times) {
        long total = 0;
        for (long time : times) {
            total += time;
        }
        return total / (float)times.size();
    }
    private static long get95Percentile(List<Long> times) {
        Collections.sort(times);
        int index = (int) Math.ceil(95 / 100.0 * times.size());
        return times.get(index-1);
    }

    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);
        CapacityTestingTool tool = new CapacityTestingTool("https://www.baidu.com", 100, pool);
        double[] metrics = tool.run();
        System.out.println("The average response time is " + metrics[0] + " \r\nseconds and the 95 " +
                "percentile response time is " + metrics[1] + " seconds");
        pool.shutdown();
    }
}


The average response time is 0.08411000061035157 
seconds and the 95 percentile response time is 0.69 seconds