脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → java性能测试框架

手写java性能测试框架第二版

 更新时间：2022年07月21日 15:25:55   作者：FunTester  
这篇文章主要为大家介绍了手写java性能测试框架第二版实现示例，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪

引言

依照领导要求区分了两种压测模式：固定次数压测和固定时间压测。此前一直沿用的都是固定次数，所以本次第二版剥离了固定次数的模式增加了固定时间的模式。

这是第一版：性能测试框架

第二版的threadbase代码如下

package com.fun.base.constaint;
import com.fun.frame.SourceCode;
import java.util.concurrent.CountDownLatch;
/**
 * 多线程任务基类，可单独使用
 */
public abstract class ThreadBase<T> extends SourceCode implements Runnable {
    /**
     * 计数锁
     * <p>
     * 会在concurrent类里面根据线程数自动设定
     * </p>
     */
    CountDownLatch countDownLatch;
    /**
     * 用于设置访问资源
     */
    public T t;
    protected ThreadBase() {
        super();
    }
    /**
     * groovy无法直接访问t，所以写了这个方法
     *
     * @return
     */
    public String getT() {
        return t.toString();
    }
    /**
     * 运行待测方法的之前的准备
     */
    protected abstract void before();
    /**
     * 待测方法
     *
     * @throws Exception
     */
    protected abstract void doing() throws Exception;
    /**
     * 运行待测方法后的处理
     */
    protected abstract void after();
    public void setCountDownLatch(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
}

固定次数模式的压测虚拟类

package com.fun.base.constaint;
import com.fun.frame.excute.Concurrent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import static com.fun.utils.Time.getTimeStamp;
/**
 * 请求时间限制的多线程类,限制每个线程执行的次数
 *
 * <p>
 * 通常在测试某项用例固定时间的场景下使用,可以提前终止测试用例
 * </p>
 *
 * @param <T> 闭包参数传递使用,Groovy脚本会有一些兼容问题,部分对象需要tostring获取参数值
 */
public abstract class ThreadLimitTimes<T> extends ThreadBase {
    private static final Logger logger = LoggerFactory.getLogger(ThreadLimitTimes.class);
    /**
     * 任务请求执行次数
     */
    public int times;
    /**
     * 用于设置访问资源
     */
    public T t;
    public ThreadLimitTimes(T t, int times) {
        this(times);
        this.t = t;
    }
    public ThreadLimitTimes(int times) {
        this();
        this.times = times;
    }
    protected ThreadLimitTimes() {
        super();
    }
    /**
     * groovy无法直接访问t，所以写了这个方法
     *
     * @return
     */
    public String getT() {
        return t.toString();
    }
    @Override
    public void run() {
        try {
            before();
            List<Long> t = new ArrayList<>();
            long ss = getTimeStamp();
            for (int i = 0; i < times; i++) {
                long s = getTimeStamp();
                doing();
                long e = getTimeStamp();
                t.add(e - s);
            }
            long ee = getTimeStamp();
            logger.info("执行次数：{}，总耗时：{}", times, ee - ss);
            Concurrent.allTimes.addAll(t);
        } catch (Exception e) {
            logger.warn("执行任务失败！", e);
        } finally {
            if (countDownLatch != null)
                countDownLatch.countDown();
            after();
        }
    }
    /**
     * 运行待测方法的之前的准备
     */
    protected abstract void before();
    /**
     * 待测方法
     *
     * @throws Exception
     */
    protected abstract void doing() throws Exception;
    /**
     * 运行待测方法后的处理
     */
    protected abstract void after();
}

固定时间模式虚拟类

package com.fun.base.constaint;
import com.fun.frame.excute.Concurrent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
import static com.fun.utils.Time.getTimeStamp;
/**
 * 请求时间限制的多线程类,限制每个线程执行的时间
 * <p>
 * 通常在测试某项用例固定时间的场景下使用,可以提前终止测试用例
 * </p>
 *
 * @param <T> 闭包参数传递使用,Groovy脚本会有一些兼容问题,部分对象需要tostring获取参数值
 */
public abstract class ThreadLimitTime<T> extends ThreadBase {
    /**
     * 全局的时间终止开关
     */
    private static boolean key = false;
    private static final Logger logger = LoggerFactory.getLogger(ThreadLimitTime.class);
    /**
     * 任务请求执行时间,单位是秒
     */
    public int time;
    /**
     * 用于设置访问资源
     */
    public T t;
    public ThreadLimitTime(T t, int time) {
        this(time);
        this.t = t;
    }
    public ThreadLimitTime(int time) {
        this();
        this.time = time * 1000;
    }
    protected ThreadLimitTime() {
        super();
    }
    @Override
    public void run() {
        try {
            before();
            List<Long> t = new ArrayList<>();
            long ss = getTimeStamp();
            while (true) {
                long s = getTimeStamp();
                doing();
                long e = getTimeStamp();
                t.add(e - s);
                if ((e - ss) > time || key) break;
            }
            long ee = getTimeStamp();
            logger.info("执行时间：{} s，总耗时：{}", time / 1000, ee - ss);
            Concurrent.allTimes.addAll(t);
        } catch (Exception e) {
            logger.warn("执行任务失败！", e);
        } finally {
            if (countDownLatch != null)
                countDownLatch.countDown();
            after();
        }
    }
    /**
     * 用于在某些情况下提前终止测试
     */
    public static void stopAllThread() {
        key = true;
    }
}

这里我多加了一个终止测试的key，暂时没有用，以防万一。之所以没有采用另起线程去计时原因有二：进行测试过程中无论如何都会记录时间戳，多余的计算比较时间戳大小消耗性能很低，可以忽略；另起线程设计麻烦，在发生意外情况时缺少第二种保险措施。

HTTPrequestbase为基础的多线程类

下面是两种实现类的Demo，以HTTPrequestbase作为基础的多线程类。

固定次数模式的多线程类

/**
 * http请求多线程类
 */
public class RequestThreadTimes extends ThreadLimitTimes {
    static Logger logger = LoggerFactory.getLogger(RequestThreadTimes.class);
    /**
     * 请求
     */
    public HttpRequestBase request;
    /**
     * 单请求多线程多次任务构造方法
     *
     * @param request 被执行的请求
     * @param times   每个线程运行的次数
     */
    public RequestThreadTimes(HttpRequestBase request, int times) {
        this.request = request;
        this.times = times;
    }
    @Override
    public void before() {
        GCThread.starts();
    }
    @Override
    protected void doing() throws Exception {
        getResponse(request);
    }
    @Override
    protected void after() {
        GCThread.stop();
    }
    /**
     * 多次执行某个请求，但是不记录日志，记录方法用 loglong
     * <p>此方法只适应与单个请求的重复请求，对于有业务联系的请求暂时不能适配</p>
     *
     * @param request 请求
     * @throws IOException
     */
    void getResponse(HttpRequestBase request) throws IOException {
        CloseableHttpResponse response = ClientManage.httpsClient.execute(request);
        String content = FanLibrary.getContent(response);
        if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK)
            logger.warn("响应状态码：{},响应内容：{}", content, response.getStatusLine());
        response.close();
    }
}

固定时间模式的多线程类

package com.fun.frame.thead;
import com.fun.base.constaint.ThreadLimitTime;
import com.fun.frame.httpclient.ClientManage;
import com.fun.frame.httpclient.FanLibrary;
import com.fun.frame.httpclient.GCThread;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpRequestBase;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
/**
 * http请求多线程类
 */
public class RequestThreadTime extends ThreadLimitTime {
    static Logger logger = LoggerFactory.getLogger(RequestThreadTime.class);
    /**
     * 请求
     */
    public HttpRequestBase request;
    /**
     * 单请求多线程多次任务构造方法
     *
     * @param request 被执行的请求
     * @param times   每个线程运行的次数
     */
    public RequestThreadTime(HttpRequestBase request, int time) {
        this.request = request;
        this.time = time;
    }
    @Override
    public void before() {
        GCThread.starts();
    }
    @Override
    protected void doing() throws Exception {
        getResponse(request);
    }
    @Override
    protected void after() {
        GCThread.stop();
    }
    /**
     * 多次执行某个请求，但是不记录日志，记录方法用 loglong
     * <p>此方法只适应与单个请求的重复请求，对于有业务联系的请求暂时不能适配</p>
     *
     * @param request 请求
     * @throws IOException
     */
    void getResponse(HttpRequestBase request) throws IOException {
        CloseableHttpResponse response = ClientManage.httpsClient.execute(request);
        String content = FanLibrary.getContent(response);
        if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK)
            logger.warn("响应状态码：{},响应内容：{}", content, response.getStatusLine());
        response.close();
    }
}

其中可以发现，差别就在于属性time还是times的设定。

使用Demo：

package com.fun;
import com.fun.base.constaint.ThreadLimitTime;
import com.fun.frame.SourceCode;
import com.fun.frame.excute.Concurrent;
import java.util.ArrayList;
import java.util.List;
public class AR extends SourceCode {
    public static void main(String[] args) {
        ThreadLimitTime<Object> threadLimitTime = new ThreadLimitTime<Object>(10) {
            /**
             * 运行待测方法的之前的准备
             */
            @Override
            protected void before() {
            }
            /**
             * 待测方法
             *
             * @throws Exception
             */
            @Override
            protected void doing() throws Exception {
                AR.test();
            }
            /**
             * 运行待测方法后的处理
             */
            @Override
            protected void after() {
            }
        };
        new Concurrent(threadLimitTime,5).start();
        FanLibrary.testOver();
    }
    public static void test() {
        synchronized (AR.class) {
            sleep(100);
            output("fun");
        }
    }
}

剩下的mysql和redis以及dubbo的Demo就不写了，各位看官看着发挥即可，更多关于java性能测试框架的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • Java单元测试Powermockito和Mockito使用总结

    Java单元测试Powermockito和Mockito使用总结

    公司单元测试框架选用了Junit 4.12，Mock框架选用了Mockito和PowerMock，本文主要介绍了Java单元测试Powermockito和Mockito使用总结，感兴趣的可以了解一下
    2021-09-09
  • Spring数据库连接池实现原理深入刨析

    Spring数据库连接池实现原理深入刨析

    开发web项目，我们肯定会和数据库打交道，因此就会涉及到数据库链接的问题。在以前我们开发传统的SSM结构的项目时进行数据库链接都是通过JDBC进行数据链接，我们每和数据库打一次交道都需要先获取一次链接，操作完后再关闭链接，这样子效率很低，因此就出现了连接池
    2022-11-11
  • java json 省市级联实例代码

    java json 省市级联实例代码

    这篇文章介绍了java json 省市级联实例代码，有需要的朋友可以参考一下
    2013-09-09
  • JAVA进程突然消失问题解决方案

    JAVA进程突然消失问题解决方案

    这篇文章主要介绍了JAVA进程突然消失问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-03-03
  • Netty分布式pipeline管道创建方法跟踪解析

    Netty分布式pipeline管道创建方法跟踪解析

    这篇文章主要为大家介绍了Netty分布式pipeline管道创建方法跟踪解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-03-03
  • GC算法实现篇之并发标记清除

    GC算法实现篇之并发标记清除

    这篇文章主要为大家介绍了GC算法实现篇之并发-标记-清除, CMS垃圾收集器在减少停顿时间上做了很多给力的工作, 大量的并发线程执行的工作并不需要暂停应用线程
    2022-01-01
  • spring retry实现方法请求重试的使用步骤

    spring retry实现方法请求重试的使用步骤

    这篇文章主要介绍了spring retry实现方法请求重试及使用步骤，本文分步骤通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2022-07-07
  • 解决idea 暂存文件或idea切换分支代码丢失的问题

    解决idea 暂存文件或idea切换分支代码丢失的问题

    这篇文章主要介绍了解决idea 暂存文件或idea切换分支代码丢失的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2021-02-02
  • JAVA中通过Hibernate-Validation进行参数验证

    JAVA中通过Hibernate-Validation进行参数验证

    这篇文章主要介绍了JAVA中通过Hibernate-Validation进行参数验证，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2019-04-04
  • 使用EasyExcel实现简单的Excel表格解析操作

    使用EasyExcel实现简单的Excel表格解析操作

    这篇文章主要介绍了如何使用EasyExcel完成简单的表格解析操作,同时实现了大量数据情况下数据的分次批量入库,并记录每条数据入库的状态,感兴趣的可以了解下
    2025-03-03

最新评论