今天写了一个可以测试并发数和运行次数的压力测试代码。（Java）

今天写了一个可以测试并发数和运行次数的压力测试代码

介绍一下为什么会写这么一个工具。
介绍一个这个工具怎么用的。

背景

最近在开发CoapServer端，以及模拟设备侧发送数据调用开发好的CoapServer的性能，进行压力测试。

自己没有找到合适的压力测试的工具，但是测试诉求相对比较简单，觉得用Java可以来控制测试。

测试维度：

一共模拟1W台设备，共计发送数据100W次
模拟多台设备同时发送数据。

代码和使用

import org.eclipse.californium.core.CoapClient;

import org.eclipse.californium.core.CoapResponse;

import org.eclipse.californium.core.Utils;

import org.eclipse.californium.elements.exception.ConnectorException;

import java.io.IOException;

import java.text.NumberFormat;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class PressTestClient {

    static int count = 0;

    //总访问量是client_num，并发量是thread_num

    int thread_num = 10;

    int client_num = 1000;

    float avg_exec_time = 0;

    float sum_exec_time = 0;

    long first_exec_time = Long.MAX_VALUE;

    long last_done_time = Long.MIN_VALUE;

    float total_exec_time = 0;

    String url = "";

    String postData = "";

    public PressTestClient(int thread_num, int client_num, String url, String postData) {

        this.thread_num = thread_num;

        this.client_num = client_num;

        this.url = url;

        this.postData = postData;

    }

    public void run() {

        final PressTestClient currentObj = this;

        final ConcurrentHashMap<Integer, ClientThreadRecord> records = new ConcurrentHashMap<Integer, ClientThreadRecord>();

        // 建立ExecutorService线程池

        ExecutorService exec = Executors.newFixedThreadPool(thread_num);

        // thread_num个线程可以同时访问

        // 模拟client_num个客户端访问

        final CountDownLatch doneSignal = new CountDownLatch(client_num);

        for (int i = 0; i < client_num; i++) {

            Runnable run = new Runnable() {

                public void run() {

                    int index = getIndex();

                    long st = System.currentTimeMillis();

                    try {

                        //测试的逻辑代码

                        TlsCoAPClient example = new TlsCoAPClient();

                        CoapClient coapClient = example.getClient("device_service");

                        CoapResponse response = null;

                        try {

                            System.out.println("start client request:" +index );

                            response = coapClient.get();

                            System.out.println("device_service: " + Utils.prettyPrint(response));

                            Thread.sleep(100);

                        } catch (ConnectorException | IOException e) {

                            e.printStackTrace();

                        }

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                    records.put(index, new ClientThreadRecord(st, System.currentTimeMillis()));

                    doneSignal.countDown();//每调用一次countDown()方法，计数器减1

                }

            };

            exec.execute(run);

        }

        try {

            //计数器大于0 时，await()方法会阻塞程序继续执行

            doneSignal.await();

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        /**

         * 获取每个线程的开始时间和结束时间

         */

        for (int i : records.keySet()) {

            ClientThreadRecord r = records.get(i);

            sum_exec_time += ((double) (r.et - r.st)) / 1000;

            if (r.st < first_exec_time) {

                first_exec_time = r.st;

            }

            if (r.et > last_done_time) {

                this.last_done_time = r.et;

            }

        }

        this.avg_exec_time = this.sum_exec_time / records.size();

        this.total_exec_time = ((float) (this.last_done_time - this.first_exec_time)) / 1000;

        NumberFormat nf = NumberFormat.getNumberInstance();

        nf.setMaximumFractionDigits(4);

        System.out.println("======================================================");

        System.out.println("Thread Num: " + thread_num + ", Client Count: " + client_num + ".");

        System.out.println("Avg Exec Time:   " + nf.format(this.avg_exec_time) + " s");

        System.out.println("Total Exec Time: " + nf.format(this.total_exec_time) + " s");

        System.out.println("Throughput:      " + nf.format(this.client_num / this.total_exec_time) + " /s");

    }

    public static int getIndex() {

        return ++count;

    }

    public static void main(String[] args) {

        //总访问量和并发量两重循环，依次增大访问

        //访问量

        for (int j = 500; j < 501; j += 100) {

            //并发量

            for (int i = 500; i < 501; i += 1) {

                //要测试的URL

                String url = "http://www.baidu.com/";

                new PressTestClient(i, j, url, "").run();

            }

        }

        System.out.println("finished!");

    }

}

class ClientThreadRecord {

    long st;

    long et;

    public ClientThreadRecord(long st, long et) {

        this.st = st;

        this.et = et;

    }

}

如何使用？

main方法中的循环此时是控制运行数和并发数的
上面run方法，是控制你要测试的代码的。可以自定义。

巴特西

今天写了一个可以测试并发数和运行次数的压力测试代码。（Java）

今天写了一个可以测试并发数和运行次数的压力测试代码

背景

代码和使用

效果展示

最新文章

热门文章