精华内容
下载资源
问答
  • 通过对实际现场的分析,确定煤泥输送系统浓料泵主缸压力预测是进行管道堵塞预测的必要前提,提出了基于网格法的支持向量机(GSVM)的浓料泵主缸压力预测模型,将网格搜索法用于支持向量机的参数优化。仿真结果表明,该GSVM...
  • 我们提出了一个新的压力参数化模型,通过将重子物质和暗物质(暗物质和暗能量)视为统一的暗流体来解释晚期宇宙的加速膨胀。 为了更实际地实现此模型,我们分别使用典型值和幻像标量场对其进行重构。 我们使用最新的...
  • 一、sysbench压力测试工具简介: sysbench是一个开源的、模块化的、跨平台的多线程性能测试工具,可以用来进行CPU、内存、磁盘I/O、线程、数据库的性能测试。目前支持的数据库有MySQL、Oracle和PostgreSQL。以下...

    一、sysbench压力测试工具简介:

     

    sysbench是一个开源的、模块化的、跨平台的多线程性能测试工具,可以用来进行CPU、内存、磁盘I/O、线程、数据库的性能测试。目前支持的数据库有MySQLOraclePostgreSQL。以下操作都将以支持MySQL数据库为例进行。

     

    1.      sysbench工具安装:

    默认支持MySQL,如果需要测试Oracle/PostgreSQL,则在configure时需要加上–with-oracle或者–with-pgsql参数.

     

    1.1          安装环境

    CentOS release 6.3 (Final)

    MySQL 5.6.13 

    MySQL_HOME=/usr/local/mysql/

    Sysbench 0.4.12

    1.2          下载安装包

    # wget http://sourceforge.net/projects/sysbench/sysbench-0.4.12.tar.gz

     

    1.3 编译安装

    #  tar –zxvf sysbench-0.4.12.tar.gz

     

    进入解压缩包sysbench-0.4.12,并执行脚本autogen.sh

     

    # cd sysbench-0.4.12

    # ./autogen.sh

     

    关键的三步:configure && make && make install

     

    首先是./configure命令,sysbench默认是支持MySQLbenchmarking的,如果不加任何选项则要求保证MySQL的安装路径都是默认的标准路径,headfile位于/usr/include目录下,libraries位于/usr/lib/目录下。因为我的MySQL是源码编译安装的,安装路径是放在/usr/local/mysql下,所以这里要添加相应的选项命令:

     

    # ./configure --prefix=/usr/local/sysbench --with-mysql=/usr/local/mysql \

    --with-mysql-includes=/usr/local/mysql/include/mysql/ \

    --with-mysql-libs=/usr/local/mysql/lib/mysql/

     

    注意:这里在编译时要将路径写到最后的include/mysql及lib/mysql,如下所示:

     

    –with-mysql-includes=/usr/local/mysql/include/mysql/

    --with-mysql-libs=/usr/local/mysql/lib/mysql/

     

    因为网上好多资料都没有提到这一层,在编译时总是编译不过去,这里浪费了好多精力。

    接下来执行如下命令:

     

    # make && make install

    1.4           yum安装

    如果觉得源码安装麻烦,也可以采用yum安装,操作如下:

     

     

    # yum install -y sysbench

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    2.      sysbench支持的功能参数

     

    首先,看看sysbench都支持哪些功能参数:

    [root@db-master sysbench]# sysbench --help

    Usage:

      sysbench [general-options]... --test= [test-options]... command

    General options:

      --num-threads=N            number of threads to use [1]

      --max-requests=N           limit for total number of requests [10000]

      --max-time=N               limit for total execution time in seconds [0]

      --forced-shutdown=STRING   amount of time to wait after --max-time before forcing shutdown [off]

      --thread-stack-size=SIZE   size of stack per thread [32K]

      --init-rng=[on|off]        initialize random number generator [off]

      --test=STRING              test to run

      --debug=[on|off]           print more debugging info [off]

      --validate=[on|off]        perform validation checks where possible [off]

      --help=[on|off]            print help and exit

      --version=[on|off]         print version and exit

    Compiled-in tests:

      fileio - File I/O test

      cpu - CPU performance test

      memory - Memory functions speed test

      threads - Threads subsystem performance test

      mutex - Mutex performance test

      oltp - OLTP test

    Commands: prepare run cleanup help version

    See 'sysbench --test= help' for a list of options for each test.

     

     

    Sysbench的测试主要包括以下几个方面:

    1、磁盘io性能

    2cpu性能

    3、内存分配及传输速度

    4POSIX线程性能

    5、调度程序性能

    6、数据库性能(OLTP基准测试).

     

     

    2.1 测试fileio命令帮助:

    [root@db-master ~]# sysbench --test=fileio help  

    sysbench 0.4.12:  multi-threaded system evaluation benchmark

    fileio options:

      --file-num=N                  number of files to create [128]

      --file-block-size=N           block size to use in all IO operations [16384]

      --file-total-size=SIZE        total size of files to create [2G]

      --file-test-mode=STRING       test mode {seqwr, seqrewr, seqrd, rndrd, rndwr, rndrw}

      --file-io-mode=STRING         file operations mode {sync,async,fastmmap,slowmmap} [sync]

      --file-async-backlog=N        number of asynchronous operatons to queue per thread [128]

      --file-extra-flags=STRING     additional flags to use on opening files {sync,dsync,direct} []

      --file-fsync-freq=N           do fsync() after this number of requests (0 - don't use fsync()) [100]

      --file-fsync-all=[on|off]     do fsync() after each write operation [off]

      --file-fsync-end=[on|off]     do fsync() at the end of test [on]

      --file-fsync-mode=STRING      which method to use for synchronization {fsync, fdatasync} [fsync]

      --file-merged-requests=N      merge at most this number of IO requests if possible (0 - don't merge) [0]

      --file-rw-ratio=N             reads/writes ratio for combined test [1.5]

     

    参数详解:

    --file-num=N          代表生成测试文件的数量,默认为128

    --file-block-size=N      测试时所使用文件块的大小,如果想磁盘针对innodb存储引擎进行测试,可以将其设置为16384,即innodb存储引擎页的大小。默认为16384

    --file-total-size=SIZE     创建测试文件的总大小,默认为2G大小。

    --file-test-mode=STRING 文件测试模式,包含:seqwr(顺序写), seqrewr(顺序读写), seqrd(顺序读), rndrd(随机读), rndwr(随机写), rndrw(随机读写)

    --file-io-mode=STRING   文件操作的模式,sync(同步),async(异步),fastmmap(快速mmap,slowmmap(慢速mmap),默认为sync同步模式。

    --file-async-backlog=N   对应每个线程队列的异步操作数,默认为128

    --file-extra-flags=STRING 打开文件时的选项,这是与API相关的参数。

    --file-fsync-freq=N      执行fsync()函数的频率。fsync主要是同步磁盘文件,因为可能有系统和磁盘缓冲的关系。 0代表不使用fsync函数。默认值为100

    --file-fsync-all=[on|off]  每执行完一次写操作,就执行一次fsync。默认为off

    --file-fsync-end=[on|off] 在测试结束时执行fsync函数。默认为on

    --file-fsync-mode=STRING文件同步函数的选择,同样是和API相关的参数,由于多个操作系统对于fdatasync支持不同,因此不建议使用fdatasync。默认为fsync

    --file-merged-requests=N 大多情况下,合并可能的IO的请求数,默认为0

    --file-rw-ratio=N         测试时的读写比例,默认时为1.5,即可32

     

    2.2 测试cpu命令帮助:

    [root@db-master ~]# sysbench --test=cpu help

    sysbench 0.4.12:  multi-threaded system evaluation benchmark

    cpu options:

      --cpu-max-prime=N      upper limit for primes generator [10000]

     

     

     参数详解:

      --cpu-max-prime=N      用来选项指定最大的素数,具体参数可以根据CPU的性能来设置,默认为10000

     

    2.3 测试memory命令帮助:

    [root@db-master ~]# sysbench  --test=memory help

    sysbench 0.4.12:  multi-threaded system evaluation benchmark

    memory options:

      --memory-block-size=SIZE    size of memory block for test [1K]

      --memory-total-size=SIZE    total size of data to transfer [100G]

      --memory-scope=STRING       memory access scope {global,local} [global]

      --memory-hugetlb=[on|off]   allocate memory from HugeTLB pool [off]

      --memory-oper=STRING        type of memory operations {read, write, none} [write]

      --memory-access-mode=STRING memory access mode {seq,rnd} [seq]

     

     

     

     

     

    参数详解:

      --memory-block-size=SIZE      测试内存块的大小,默认为1K

      --memory-total-size=SIZE       数据传输的总大小,默认为100G

      --memory-scope=STRING       内存访问的范围,包括全局和本地范围,默认为global

      --memory-hugetlb=[on|off]     是否从HugeTLB池分配内存的开关,默认为off

      --memory-oper=STRING        内存操作的类型,包括read, write, none,默认为write

      --memory-access-mode=STRING 内存访问模式,包括seq,rnd两种模式,默认为seq

     

     

     

    2.4 测试threads命令帮助: 

    [root@db-master ~]# sysbench  --test=threads help

    sysbench 0.4.12:  multi-threaded system evaluation benchmark

    threads options:

      --thread-yields=N      number of yields to do per request [1000]

      --thread-locks=N       number of locks per thread [8]

     

    参数详解: 

      --thread-yields=N      指定每个请求的压力,默认为1000

      --thread-locks=N       指定每个线程的锁数量,默认为8

     

      

    2.5 测试mutex命令帮助:

    [root@db-master ~]# sysbench  --test=mutex help 

    sysbench 0.4.12:  multi-threaded system evaluation benchmark

    mutex options:

      --mutex-num=N        total size of mutex array [4096]

      --mutex-locks=N      number of mutex locks to do per thread [50000]

      --mutex-loops=N      number of empty loops to do inside mutex lock [10000]

     

    参数详解

      --mutex-num=N    数组互斥的总大小。默认是4096

      --mutex-locks=N    每个线程互斥锁的数量。默认是50000

      --mutex-loops=N    内部互斥锁的空循环数量。默认是10000

    2.6 测试oltp命令帮助:  

     

    [root@db-master ~]# sysbench --test=oltp help 

    sysbench 0.4.12:  multi-threaded system evaluation benchmark

    oltp options:

      --oltp-test-mode=STRING         test type to use {simple,complex,nontrx,sp} [complex]

      --oltp-reconnect-mode=STRING    reconnect mode {session,transaction,query,random} [session]

      --oltp-sp-name=STRING           name of store procedure to call in SP test mode []

      --oltp-read-only=[on|off]       generate only 'read' queries (do not modify database) [off]

      --oltp-skip-trx=[on|off]        skip BEGIN/COMMIT statements [off]

      --oltp-range-size=N             range size for range queries [100]

      --oltp-point-selects=N          number of point selects [10]

      --oltp-simple-ranges=N          number of simple ranges [1]

      --oltp-sum-ranges=N             number of sum ranges [1]

      --oltp-order-ranges=N           number of ordered ranges [1]

      --oltp-distinct-ranges=N        number of distinct ranges [1]

      --oltp-index-updates=N          number of index update [1]

      --oltp-non-index-updates=N      number of non-index updates [1]

      --oltp-nontrx-mode=STRING       mode for non-transactional test {select, update_key, update_nokey, insert, delete} [select]

      --oltp-auto-inc=[on|off]        whether AUTO_INCREMENT (or equivalent) should be used on id column [on]

      --oltp-connect-delay=N          time in microseconds to sleep after connection to database [10000]

      --oltp-user-delay-min=N         minimum time in microseconds to sleep after each request [0]

      --oltp-user-delay-max=N         maximum time in microseconds to sleep after each request [0]

      --oltp-table-name=STRING        name of test table [sbtest]

      --oltp-table-size=N             number of records in test table [10000]

      --oltp-dist-type=STRING         random numbers distribution {uniform,gaussian,special} [special]

      --oltp-dist-iter=N              number of iterations used for numbers generation [12]

      --oltp-dist-pct=N               percentage of values to be treated as 'special' (for special distribution) [1]

      --oltp-dist-res=N               percentage of 'special' values to use (for special distribution) [75]

    General database options:

      --db-driver=STRING  specifies database driver to use ('help' to get list of available drivers)

      --db-ps-mode=STRING prepared statements usage mode {auto, disable} [auto]

     

    Compiled-in database drivers:

      mysql - MySQL driver

      pgsql - PostgreSQL driver

    mysql options:

      --mysql-host=[LIST,...]       MySQL server host [localhost]

      --mysql-port=N                MySQL server port [3306]

      --mysql-socket=STRING         MySQL socket

      --mysql-user=STRING           MySQL user [sbtest]

      --mysql-password=STRING       MySQL password []

      --mysql-db=STRING             MySQL database name [sbtest]

      --mysql-table-engine=STRING   storage engine to use for the test table {myisam,innodb,bdb,heap,ndbcluster,federated} [innodb]

      --mysql-engine-trx=STRING     whether storage engine used is transactional or not {yes,no,auto} [auto]

      --mysql-ssl=[on|off]          use SSL connections, if available in the client library [off]

      --myisam-max-rows=N           max-rows parameter for MyISAM tables [1000000]

      --mysql-create-options=STRING additional options passed to CREATE TABLE []

    pgsql options:

      --pgsql-host=STRING     PostgreSQL server host [localhost]

      --pgsql-port=N          PostgreSQL server port [5432]

      --pgsql-user=STRING     PostgreSQL user [sbtest]

      --pgsql-password=STRING PostgreSQL password []

      --pgsql-db=STRING       PostgreSQL database name [sbtest]

     

     

    参数详解:

     

      --oltp-test-mode=STRING    执行模式{simple,complex(advanced transactional),nontrx(non-transactional),sp}。默认是complex

      --oltp-reconnect-mode=STRING 重新连接模式{session(不使用重新连接。每个线程断开只在测试结束),transaction(在每次事务结束后重新连接),query(在每个SQL语句执行完重新连接),random(对于每个事务随机选择以上重新连接模式)}。默认是session

      --oltp-sp-name=STRING   存储过程的名称。默认为空

      --oltp-read-only=[on|off]  只读模式。Updatedeleteinsert语句不可执行。默认是off

      --oltp-skip-trx=[on|off]   省略begin/commit语句。默认是off

      --oltp-range-size=N      查询范围。默认是100

      --oltp-point-selects=N          number of point selects [10]

      --oltp-simple-ranges=N          number of simple ranges [1]

      --oltp-sum-ranges=N             number of sum ranges [1]

      --oltp-order-ranges=N           number of ordered ranges [1]

      --oltp-distinct-ranges=N        number of distinct ranges [1]

      --oltp-index-updates=N          number of index update [1]

      --oltp-non-index-updates=N      number of non-index updates [1]

      --oltp-nontrx-mode=STRING   查询类型对于非事务执行模式{select, update_key, update_nokey, insert, delete} [select]

      --oltp-auto-inc=[on|off]      AUTO_INCREMENT是否开启。默认是on

      --oltp-connect-delay=N     在多少微秒后连接数据库。默认是10000

      --oltp-user-delay-min=N    每个请求最短等待时间。单位是ms。默认是0

      --oltp-user-delay-max=N    每个请求最长等待时间。单位是ms。默认是0

      --oltp-table-name=STRING  测试时使用到的表名。默认是sbtest

      --oltp-table-size=N         测试表的记录数。默认是10000

      --oltp-dist-type=STRING    分布的随机数{uniform(均匀分布),Gaussian(高斯分布),special(空间分布)}。默认是special

      --oltp-dist-iter=N    产生数的迭代次数。默认是12

      --oltp-dist-pct=N    值的百分比被视为'special' (for special distribution)。默认是1

      --oltp-dist-res=N    special’的百分比值。默认是75

     

     

    3.      总结:

    以上就是sysbench工具的安装配置及相关选项参数的介绍,可以根据自己的需要添加对应的参数进行压力测试即可。在下一篇文档中将会对上面的几种模式进行相应的测试。

    http://blog.chinaunix.net/uid-7589639-id-4123266.html

     

    转载于:https://www.cnblogs.com/chen110xi/p/6336931.html

    展开全文
  • 转载请注明出处,感谢您的支持。 文章来源:【chenyk的博客】http://blog.csdn.net/chenyk_kevin_1/article/details/79546175 简单说明 参数化的一般用法就是将脚本中的某些输入使用参数来代替,在脚本运行时...

    转载请注明出处,感谢您的支持。
    文章来源:【chenyk的博客】http://blog.csdn.net/chenyk_kevin_1/article/details/79546175

    简单说明


    参数化的一般用法就是将脚本中的某些输入使用参数来代替,在脚本运行时指定参数的取值范围和规则。
    关于Jmeter的参数化请求包括以下几种方式:
    * 用户参数
    * BeanShell Sampler
    * 用户定义的变量
    * CSV Data Set Config
    * 随机函数

    用户参数


    操作:添加 -> 前置处理器 -> 用户参数
    调用方式:${defineCount}

    用户参数

    PS:多用户仅对多线程有效,单线程只取第一个用户的值

    BeanShell Sampler


    操作:添加 -> 前置处理器 -> BeanShell Sampler -> 在Script中按以下格式设置参数
    调用方式:${defineCount}

    BeanShell Sampler

    用户定义的变量


    操作:添加 -> 配置元件 -> 用户定义的变量
    调用方式:${defineCount}

    用户定义的变量

    CSV Data Set Config


    操作:添加 -> 配置元件 -> CSV Data Set Config
    调用方式:${defineCount}

    CSV Data Set Config

    PS:如果需要使用多个参数的话,需在Variable Names一栏以Deliniter定义的符号(一般此项为逗号[ , ])进行分割,当然对应的csv文件数据源,每一行也要以相应的格式进行分隔

    多个参数

    随机函数


    操作:菜单栏上选择选项 -> 函数助手对话框 -> 配置参数并复制生成随机字符串 -> 粘贴字符串到目标位置
    调用方式:${__RandomString(2,123456845612314578456123,)}

    打开函数助手对话框

    随机函数字符串生成

    将复制的字符串,粘贴到目标位置上,如下所示:

    粘贴随机函数字符串

    写在最后,希望以上内容能帮到您,不定时总结和记录个人的经验。您的支持是我前进的动力,经验分享是美德

    展开全文
  • 本次新增对每组参数采用协程压测的方式进行压测yaml 管理用例支持登陆成功后返回 token 或者 user_id 给其他接口使用,如果接参数需要多个加密参数,留了扩展,自己去封装检查点采用检查接口和访问数据库的方式进行...

    本次新增

    对每组参数采用协程压测的方式进行压测

    yaml 管理用例

    支持登陆成功后返回 token 或者 user_id 给其他接口使用,如果接参数需要多个加密参数,留了扩展,自己去封装

    检查点采用检查接口和访问数据库的方式进行检查

    如果正常参数直接访问数据库,如果是异常参数直接读取接口返回值

    注意此框架暂时还是探索阶段,有什么好想法欢迎提供

    常用配置

    全局变量

    PICT_PARAMS = "d:/params.txt" # 请求参数存放地址txt

    PICT_PARAMS_RESULT = "d:/t2.txt" # 参数配对后的路径excel

    # 数据库的常用字段

    FIND_BY_SQL = "findBySql" # 根据sql查找

    COUNT_BY_SQL = "countBySql" # 自定义sql 统计影响行数

    INSERT = "insert" # 插入

    UPDATE_BY_ATTR = "updateByAttr" # 更新数据

    DELETE_BY_ATTR = "deleteByAttr" # 删除数据

    FIND_BY_ATTR = "findByAttr" # 根据条件查询一条记录

    FIND_ALL_BY_ATTR = "findAllByAttr" #根据条件查询多条记录

    COUNT = "count" # 统计行

    EXIST = "exist" # 是否存在该记录

    #接口简单点中的erro定义

    NORMAL = "0" # 正常参数,可以到表里面找到

    DEFAULT = "1" # 无此参数

    EMPTY = "2" # 参数为空值,如name=''

    DROP = "3" # 数据库中找不到此参数

    # 接口统计

    LOGIN_KEY = "" # 登陆后返回的key

    LOGIN_VALUE = "" # 登陆后返回的value

    RESULT = {"info": []} # 存最后结果

    api.yaml

    ---

    title: XXXX接口测试

    host: rap.taobao.org

    port: 80

    protocol: http://

    header: {"Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8","User-Agent":"Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.59 Safari/537.36"}

    database: {"databaseName":userinfo,"host":"127.0.0.1", "user": "root", "password": "", "port": 3306, "charset": "utf8"} #配置数据库

    api_list:

    - id: 1001

    name: 登陆

    method: post

    url: /mockjs/11463/login

    stress: 2

    hope_sql: {"findKey": "findBySql", "sql": "select * from info", "params": { }} #注意findKey的值,要对应全局变量里面的值

    params:

    - "user_name:user_name:error:0:send_keys:333:type:str,user_name:error:1,user_name:error:2,user_name:error:3:send_keys:22222:type:str"

    - "pwd:pwd:error:0:send_keys:111:type:str,pwd:error:1,pwd:error:2,pwd:error:3:send_keys:32321:type:str"

    # 注意这里的error,对应全局变量里面的error

    is_first: 1 # 预览的登陆接口

    login_key: user_id # 返回给其他接口使用的key

    - id: 1002

    ...

    get_login_param: 1 # 需要登陆接口返回过来的参数

    核心代码分析

    入口代码

    from DAL import httpConfig as hc

    from DAL import gevents, dbConnection, httpParams

    from common import operateYaml

    from DAL.pairs import *

    PATH = lambda p: os.path.abspath(

    os.path.join(os.path.dirname(__file__), p)

    )

    def myRequest(**kwargs):

    # {"appStatus": {"errorCode": 0,"message": "操作成功"},"content": {"nickname":"1212121","user_id": 30}} 接口定义的规则

    # 现在只是考虑到了登陆后返回token,user_id这方面的需求

    method = kwargs["param_req"]["method"]

    get_login_params = 0 # 标识接受了返回多少个参数(user_id,token),用作后面拓展

    param = httpParams.params_filter(kwargs["param_result"]) # 请求参数的处理,如果这里有各种加密可从此处扩展

    # get_login_param表示此接口需要登陆返回来的id(token),一般登陆成功后返回的字段

    if kwargs["param_req"].get("is_first", "false") == "false" and kwargs["param_req"].get("get_login_param", "false") != "false":

    param[Const.LOGIN_KEY]= Const.LOGIN_VALUE

    get_login_params += 1

    if kwargs["param_req"]["method"] == Const.HTTP_POST:

    really_result = kwargs["http_config"].post(dict_post=kwargs["param_req"], param=param) # 发送post请求

    elif kwargs["param_req"]["method"] == Const.HTTP_GET:

    really_result = kwargs["http_config"].get(dict_get=kwargs["param_req"], param=param) # 发送get请求

    if really_result.get("status_code") == 200:

    print("请求%s成功鸟" %method)

    if kwargs["param_req"].get("is_first", "false") != "false" :

    # 需要接口返回过来的login_key,如token,user_id)等,此时就不用查数据库作为检查点,检查点为直接读取响应结果

    if really_result["appStatus"]["errorCode"] == 0:

    Const.LOGIN_KEY = kwargs["param_req"]["login_key"]

    Const.LOGIN_VALUE = really_result["content"][Const.LOGIN_KEY]

    print("%s接口验证通过,不查数据库" %method)

    kwargs["result"]["success"] += 1

    else:

    print("%s接口测试失败,不查数据库~" %method)

    kwargs["result"]["failed"] += 1

    #如果实际的参数是异常,is_first表示是非登陆接口,就不查数据库.

    elif len(kwargs["param_result"].keys()) != len(param) - get_login_params:

    #根据接口返回的errorCode判断,假如errorCode=2表示参数异常

    if really_result["appStatus"]["errorCode"] == 2:

    print("%s接口异常参数检测通过" % method)

    kwargs["result"]["success"] += 1

    else:

    print("%s接口异常参数检测失败" % method)

    kwargs["result"]["failed"] += 1

    return

    else: #直接查询数据库作为检查点

    check_sql_key = kwargs["param_req"]["hope_sql"]["findKey"] # 根据这里的key,来跳转到不同的数据库查询语句

    kwargs["param_req"]["hope_sql"]["params"] = param # 已经处理好的请求参数传给数据库sql语句参数,结果为:params{"a":"b"}

    for item in kwargs["param_result"]:

    # error: 0正常,1无此参数,2参数的值为空,3在数据库中不存.0和3查数据库,1,2直接读取接口返回信息

    error = kwargs["param_result"][item]["error"]

    if error == Const.NORMAL or error == Const.DROP:

    if kwargs["check_sql"].findKeySql(check_sql_key, **kwargs["param_req"]["hope_sql"]):

    print("%s数据库接口验证成功" %method)

    kwargs["result"]["success"] += 1

    else:

    print("%s数据库接口验证失败" %method)

    kwargs["result"]["failed"] += 1

    return

    elif error == Const.DEFAULT or error == Const.EMPTY:

    if really_result["appStatus"]["errorCode"] == 2: # 接口返回的2为参数异常

    print("%s接口异常参数检测成功" %method)

    kwargs["result"]["success"] += 1

    else:

    print("%s接口异常参数检测失败" % method)

    kwargs["result"]["failed"] += 1

    return

    else:

    print("请求发送失败,状态码为:%s" % really_result.get("status_code"))

    def gevent_request(**kwargs):

    for i in kwargs["api_config"]: # 读取各个接口的配置,api.ymal

    # 生成参数

    pict_param(params=i["params"], pict_params=Const.PICT_PARAMS,

    pict_params_result=Const.PICT_PARAMS_RESULT)

    # 读取参数

    get_param = read_pict_param(Const.PICT_PARAMS_RESULT)

    count = len(get_param) # 根据不同分组参数,循环请求

    green_let = []

    req = {}

    for key in i:

    if key != "params": # 过滤请求参数,参数上面已经处理好了

    req[key] = i[key]

    result = {} # 统计数据

    result["name"] = req["name"] # 接口名字

    result["method"] = req["method"]

    result["url"] = req["url"]

    result["sum"] = count

    result["stress"] = req["stress"]

    result["success"] = 0

    result["failed"] = 0

    kwargs["result"] = result

    for k in range(0, count):

    kwargs["param_result"] = get_param[k] # 接口中不同的参数组合,是dict类型

    kwargs["param_req"] = req #每次请求除组合参数之外的参数,如逾期只,请求的url,method,结束等

    for item in range(kwargs["param_req"]["stress"]): # 压力测试,启动协程去压测

    green_let.append(gevents.requestGevent(myRequest(**kwargs)))

    for k in range(0, kwargs["param_req"]["stress"]):

    green_let[k].start()

    for k in range(0, kwargs["param_req"]["stress"]):

    green_let[k].join()

    Const.RESULT["info"].append(kwargs["result"])

    def get_config(api_ymal):

    '''

    得到api.ymal中的设置的接口信息

    :param api_ymal:

    :return:

    '''

    http_config = {} # http信息的记录

    api_config = [] # api的记录记录

    get_api_list = operateYaml.getYam(api_ymal)

    for key in get_api_list:

    if type(get_api_list[key]) != list:

    http_config[key] = get_api_list[key]

    else:

    api_config = get_api_list[key]

    return http_config, api_config

    if __name__ == "__main__":

    start_time = time.time()

    get_api_config = get_config(PATH("api.ymal"))

    http_conf = hc.ConfigHttp(dict_http=get_api_config[0]) # http请求的设置

    apiConfigs = get_api_config[1]

    check_sql = dbConnection. MySQLet(host=get_api_config[0]["database"]["host"], user=get_api_config[0]["database"]["user"],

    password=get_api_config[0]["database"]["password"], charset=get_api_config[0]["database"]["charset"],

    database=get_api_config[0]["database"]["databaseName"], port=get_api_config[0]["database"]["port"])

    gevent_request(http_config=http_conf, api_config=get_api_config[1], check_sql=check_sql)

    check_sql.close()

    end_time = time.time()

    print("共花费:""%.2f" % (end_time - start_time))

    print(Const.RESULT)

    封装好的访问数据库,查看主要代码来自这里,我修改了一些东西和 bug

    import mysql.connector

    import mysql.connector.errors

    from common.customConst import Const

    class MySQLet:

    """Connection to a MySQL"""

    # def __init__(self,user='',password='',database='',charset=None,port=3306):

    def __init__(self,**kwargs):

    try:

    self._conn = mysql.connector.connect(host=kwargs["host"], user=kwargs["user"], password=kwargs["password"],

    charset=kwargs["charset"], database=kwargs["database"], port=kwargs["port"])

    self.__cursor = None

    print("连接数据库")

    #set charset charset = ('latin1','latin1_general_ci')

    except mysql.connector.errors.ProgrammingError as err:

    print('mysql连接错误:' + err.msg)

    # def findBySql(self, sql, params={}, limit=0, join='AND'):

    def findBySql(self, **kwargs):

    """

    自定义sql语句查找

    limit = 是否需要返回多少行

    params = dict(field=value)

    join = 'AND | OR'

    """

    print("-----------findbysql-----")

    print(kwargs)

    cursor = self.__getCursor()

    # sql = self.__joinWhere(kwargs["sql"], kwargs["params"], kwargs["join"])

    if kwargs.get("join", 0) == 0: kwargs["join"] = "AND"

    if kwargs.get("limit", "0") == "0": kwargs["limit"] = 1

    sql = self.__joinWhere(**kwargs)

    cursor.execute(sql, tuple(kwargs["params"].values()))

    rows = cursor.fetchmany(size=kwargs["limit"]) if kwargs["limit"] > 0 else cursor.fetchall()

    result = [dict(zip(cursor.column_names,row)) for row in rows] if rows else None

    return result

    # def countBySql(self,sql,params = {},join = 'AND'):

    def countBySql(self, **kwargs):

    """自定义sql 统计影响行数"""

    if kwargs.get("join", 0) == 0: kwargs["join"] = "AND"

    cursor = self.__getCursor()

    # sql = self.__joinWhere(kwargs["sql"], kwargs["params"], kwargs["join"])

    sql = self.__joinWhere(**kwargs)

    cursor.execute(sql, tuple(kwargs["params"].values()))

    result = cursor.fetchall() # fetchone是一条记录, fetchall 所有记录

    return len(result) if result else 0

    # def insert(self,table,data):

    def insert(self, **kwargs):

    """新增一条记录

    table: 表名

    data: dict 插入的数据

    """

    fields = ','.join('`'+k+'`' for k in kwargs["data"].keys())

    values = ','.join(("%s", ) * len(kwargs["data"]))

    sql = 'INSERT INTO `%s` (%s) VALUES (%s)' % (kwargs["table"], fields, values)

    cursor = self.__getCursor()

    cursor.execute(sql, tuple(kwargs["data"].values()))

    insert_id = cursor.lastrowid

    self._conn.commit()

    return insert_id

    # def updateByAttr(self,table,data,params={},join='AND'):

    def updateByAttr(self, **kwargs):

    # """更新数据"""

    if kwargs.get("params", 0) == 0:

    kwargs["params"] = {}

    if kwargs.get("join", 0) == 0:

    kwargs["join"] = "AND"

    fields = ','.join('`' + k + '`=%s' for k in kwargs["data"].keys())

    values = list(kwargs["data"].values())

    values.extend(list(kwargs["params"].values()))

    sql = "UPDATE `%s` SET %s " % (kwargs["table"], fields)

    kwargs["sql"] = sql

    sql = self.__joinWhere(**kwargs)

    cursor = self.__getCursor()

    cursor.execute(sql, tuple(values))

    self._conn.commit()

    return cursor.rowcount

    # def updateByPk(self,table,data,id,pk='id'):

    def updateByPk(self, **kwargs):

    """根据主键更新,默认是id为主键"""

    return self.updateByAttr(**kwargs)

    # def deleteByAttr(self,table,params={},join='AND'):

    def deleteByAttr(self, **kwargs):

    """删除数据"""

    if kwargs.get("params", 0) == 0:

    kwargs["params"] = {}

    if kwargs.get("join", 0) == 0:

    kwargs["join"] = "AND"

    # fields = ','.join('`'+k+'`=%s' for k in kwargs["params"].keys())

    sql = "DELETE FROM `%s` " % kwargs["table"]

    kwargs["sql"] = sql

    # sql = self.__joinWhere(sql, kwargs["params"], kwargs["join"])

    sql = self.__joinWhere(**kwargs)

    cursor = self.__getCursor()

    cursor.execute(sql, tuple(kwargs["params"].values()))

    self._conn.commit()

    return cursor.rowcount

    # def deleteByPk(self,table,id,pk='id'):

    def deleteByPk(self, **kwargs):

    """根据主键删除,默认是id为主键"""

    return self.deleteByAttr(**kwargs)

    # def findByAttr(self,table,criteria = {}):

    def findByAttr(self, **kwargs):

    """根據條件查找一條記錄"""

    return self.__query(**kwargs)

    # def findByPk(self,table,id,pk='id'):

    def findByPk(self, **kwargs):

    return self.findByAttr(**kwargs)

    # def findAllByAttr(self,table,criteria={}, whole=true):

    def findAllByAttr(self, **kwargs):

    """根據條件查找記錄"""

    return self.__query(**kwargs)

    # def count(self,table,params={},join='AND'):

    def count(self, **kwargs):

    """根据条件统计行数"""

    if kwargs.get("join", 0) == 0: kwargs["join"] = "AND"

    sql = 'SELECT COUNT(*) FROM `%s`' % kwargs["table"]

    # sql = self.__joinWhere(sql, kwargs["params"], kwargs["join"])

    kwargs["sql"] = sql

    sql = self.__joinWhere(**kwargs)

    cursor = self.__getCursor()

    cursor.execute(sql, tuple(kwargs["params"].values()))

    result = cursor.fetchone()

    return result[0] if result else 0

    # def exist(self,table,params={},join='AND'):

    def exist(self, **kwargs):

    """判断是否存在"""

    return self.count(**kwargs) > 0

    def close(self):

    """关闭游标和数据库连接"""

    if self.__cursor is not None:

    self.__cursor.close()

    self._conn.close()

    def __getCursor(self):

    """获取游标"""

    if self.__cursor is None:

    self.__cursor = self._conn.cursor()

    return self.__cursor

    # def __joinWhere(self,sql,params,join):

    def __joinWhere(self, **kwargs):

    """转换params为where连接语句"""

    if kwargs["params"]:

    keys,_keys = self.__tParams(**kwargs)

    where = ' AND '.join(k+'='+_k for k,_k in zip(keys,_keys)) if kwargs["join"] == 'AND' else ' OR '.join(k+'='+_k for k,_k in zip(keys,_keys))

    kwargs["sql"]+=' WHERE ' + where

    return kwargs["sql"]

    # def __tParams(self,params):

    def __tParams(self, **kwargs):

    keys = ['`'+k+'`' for k in kwargs["params"].keys()]

    _keys = ['%s' for k in kwargs["params"].keys()]

    return keys,_keys

    # def __query(self,table,criteria,whole=False):

    def __query(self, **kwargs):

    if kwargs.get("whole", False) == False or kwargs["whole"] is not True:

    kwargs["whole"] = False

    kwargs["criteria"]['limit'] = 1

    # sql = self.__contact_sql(kwargs["table"], kwargs["criteria"])

    sql = self.__contact_sql(**kwargs)

    cursor = self.__getCursor()

    cursor.execute(sql)

    rows = cursor.fetchall() if kwargs["whole"] else cursor.fetchone()

    result = [dict(zip(cursor.column_names, row)) for row in rows] if kwargs["whole"] else dict(zip(cursor.column_names, rows)) if rows else None

    return result

    # def __contact_sql(self,table,criteria):

    def __contact_sql(self, **kwargs):

    sql = 'SELECT '

    if kwargs["criteria"] and type(kwargs["criteria"]) is dict:

    #select fields

    if 'select' in kwargs["criteria"]:

    fields = kwargs["criteria"]['select'].split(',')

    sql+= ','.join('`'+field+'`' for field in fields)

    else:

    sql+=' * '

    #table

    sql+=' FROM `%s`'% kwargs["table"]

    #where

    if 'where' in kwargs["criteria"]:

    sql+=' WHERE '+ kwargs["criteria"]['where']

    #group by

    if 'group' in kwargs["criteria"]:

    sql+=' GROUP BY '+ kwargs["criteria"]['group']

    #having

    if 'having' in kwargs["criteria"]:

    sql+=' HAVING '+ kwargs["criteria"]['having']

    #order by

    if 'order' in kwargs["criteria"]:

    sql+=' ORDER BY '+ kwargs["criteria"]['order']

    #limit

    if 'limit' in kwargs["criteria"]:

    sql+=' LIMIT '+ str(kwargs["criteria"]['limit'])

    #offset

    if 'offset' in kwargs["criteria"]:

    sql+=' OFFSET '+ str(kwargs["criteria"]['offset'])

    else:

    sql+=' * FROM `%s`'% kwargs["table"]

    return sql

    def findKeySql(self, key ,**kwargs):

    print("-----------")

    print(key)

    sqlOperate = {

    Const.COUNT: lambda: self.count(**kwargs),

    Const.COUNT_BY_SQL: lambda: self.countBySql(**kwargs),

    Const.DELETE_BY_ATTR: lambda: self.deleteByAttr(**kwargs),

    Const.EXIST: lambda: self.exist(**kwargs),

    Const.FIND_ALL_BY_ATTR: lambda: self.findAllByAttr(**kwargs),

    Const.INSERT: lambda: self.insert(**kwargs),

    Const.FIND_BY_ATTR: lambda: self.findByAttr(**kwargs),

    Const.UPDATE_BY_ATTR: lambda: self.updateByAttr(**kwargs),

    Const.FIND_BY_SQL: lambda: self.findBySql(**kwargs)

    }

    return sqlOperate[key]()

    if __name__ == "__main__":

    mysqlet = MySQLet(host="127.0.0.1", user="root", password="", charset="utf8", database="userinfo", port=3306)

    # 根据字段统计count, join>>AND,OR,可以不传,默认为AND

    # print(mysqlet.findKeySql(Const.COUNT, table="info", params={"id": "11", "name": "666"}, join="OR"))

    # # 自定义sql语句统计count

    # print(mysqlet.findKeySql(Const.COUNT_BY_SQL, sql="select * from info", params={"name": "666"}, join="AND"))

    # #插入数据

    # print(mysqlet.findKeySql(Const.INSERT, table="info", data={"name":"333", "pwd": "111"}))

    测试结果分析

    现在只是简单的记录下结果,后续优化

    #{'method': 'post', 'success': 32, 'stress': 2, 'failed': 0, 'url': '/mockjs/11463/login', 'name': '登陆', 'sum': 16}

    '''

    sum 表示此接口有16组参数

    stress: 表示每组参数压测两次

    method: 请求方法

    success: 成功请求次数

    failed:失败请求次数

    url:请求的网址

    name:接口名字

    '''

    其他

    后面会简单把结果记录到 excel 中,发邮件

    最终的目的是想做成平台化,这里估计短时间内无法完成

    展开全文
  • (3)支持匿名函数和闭包 (4)函数本身就是一种类型,可以赋值给变量 (5)返回值可以被命名,当返回值都被命名时,return语句之后可以没有参数,比如: func calc(a, b int) (sum int, avg int) { sum = a + ...

    1. go中函数有以下几个特点:

    (1)可返回多个值,但需用括号将返回值类型括起来

    (2)参数个数可变,可以理解为切片,使用...表示

    (3)支持匿名函数和闭包

    (4)函数本身就是一种类型,可以赋值给变量

    (5)返回值可以被命名,当返回值都被命名时,return语句之后可以没有参数,比如:

    func calc(a, b int) (sum int, avg int) {
        sum = a + b
        avg = (a + b) / 2
    
        return
    }

    但当代码较长时,该写法会影响代码可读性,故只建议在上面这种代码比较简短的情况时使用

    明明返回参数允许defer延迟调用通过闭包读取和修改:

    package main
    
    func add(x, y int) (z int) {
    	defer func() {
    		z += 100
    	}()
    
    	z = x + y
    	return
    }
    func main() {
    	println(add(1,2))
    }

    运行结果:

    package main
    
    func add(x, y int) (z int) {
    	defer func() {
    		println(z)
    		z += 100
    	}()
    
    	z = x + y
    	return z + 200
    }
    func main() {
    	println(add(1,2))
    }

    运行结果:

    由输出结果可以看出,defer会将函数的return延迟,待defer内的函数执行完之后才会返回,所以才会输出两个不一样的数字,由此可以看出上例add函数中的执行顺序为 z=z+200 ——> call defer ——>return

    2. 关于go中函数可变参数的一个实例如下:

    package main
    
    import (
    	"fmt"
    )
    
    func test(s string, n ...int) string {
    	var x int
    	for _, i := range n {
    		x += i
    	}
    	return fmt.Sprintf(s,x)
    }
    
    func main() {
    	println(test("sum: %d",1, 2, 3))
    	s := []int{1, 2, 3}
    	res := test("sum: %d", s...) //使用slice对象做变参时,必须要使用...展开
    	println(res)
    }

    3. 多返回值可直接作为其他函数的实参来调用

    package main
    
    func test() (int, int) {
    	return 1, 2
    }
    
    func add(x, y int) int {
    	return x + y
    }
    
    func sum(n ...int) int {
    	var x int
    	for _, i := range n {
    		x += i
    	}
    	return x
    }
    func main() {
    	println(add(test()))
    	println(sum(test()))
    }

    4. 匿名函数

    匿名函数由一个不带函数名和函数声明和函数体构成,其优越性在于可以直接使用函数体内的变量,不必声明

    几种用法的实例如下:

    package main
    
    import (
    	"fmt"
    	"math"
    )
    func main() {
    	//1.赋值给变量
    	getSqrt := func(a float64) float64 {
    		return math.Sqrt(a)
    	}
    	fmt.Println(getSqrt(4))
    
    	fn := func() {println("Hello World!")}
    	fn()
    
    	//2.函数集合
    	fns := [](func (x int) int) {
    		func(x int) int {return x + 1},
    		func(x int) int {return x + 2},
    	}
    	println(fns[0](100))
    
    	//3.可赋值给变量,作为结构字段
    	d := struct {
    		fn func() string
    	}{
    		fn: func() string {return "Hello, World!"},
    	}
    	println(d.fn())
    
    	//channel of function
    	fc := make(chan func() string, 2)
    	fc <- func() string {return "Hello, World!"}
    	println((<-fc)())
    }

    运行结果:

     

    5. 延迟调用(defer)

    defer特性:

    1. 关键字defer用于注册延迟调用

    2. 这些调用直到return前才被执行。因此,可以用来做资源清理

    3. 多个defer语句,按先进后出的方式执行

    4. defer语句中的变量,在defer声明时就决定了

    defer用途:

    1. 关闭文件句柄

    2. 锁资源释放

    3. 数据库连接释放

    (1)defer先进后出,因为后面的语句会依赖前面的资源,因此如果前面的资源先释放了,后面的语句就没法执行了

    一个实例如下:

    package main
    
    import (
    	"fmt"
    )
    
    func main() {
    	var whatever [5]struct{}
    
    	for i := range whatever {
    		defer fmt.Println(i)
    	}
    }
    

     运行结果:

    一个很容易犯错的地方(看下面这两个例子):

    package main
    
    import "fmt"
    
    type Test struct {
    	name string
    }
    
    func (t *Test) Close() {
    	fmt.Println(t.name, " closed")
    }
    
    func main() {
    	ts := []Test{{"a"}, {"b"}, {"c"}}
    	for _, t := range ts {
    		defer t.Close()
    	}
    }
    

    package main
    
    import "fmt"
    
    type Test struct {
    	name string
    }
    
    func (t *Test) Close() {
    	fmt.Println(t.name, " closed")
    }
    
    func main() {
    	ts := []Test{{"a"}, {"b"}, {"c"}}
    	for _, t := range ts {
    		t2 := t
    		defer t2.Close()
    	}
    }
    

    上面两个例子,只差了一个看似多此一举的声明t2,结果却完全不同,第一个例子是我们需要注意的,不要这样的错误

    至于为什么会有这种差异,由官方文档的解释来看,有如下结论:

    defer后面的语句在执行的时候,函数调用的参数会被保存起来,但是不执行。也就是复制了一份,但是并没有说struct这里的this指针如何处理,通过上述例子可以看出go语言并没有把这个明确写出来的this指针当作参数来看待。

    defer用于http.Get失败时抛出异常

    package main
    
    import (
    	"net/http"
    )
    
    func do() error {
    	res, err := http.Get("http://www.google.com")
    	if res != nil {  //注意这里一定要判别res是否为nil,这是http.Get的一个警告,否则会将错误返回而造成panic
    		defer res.Body.Close()
    	}
    	if err != nil {
    		return err
    	}
    	return nil
    }
    func main() {
    	do()
    }
    

    6. 异常处理

    Go没有结构化一场,使用panic抛出错误,recover捕获错误。

    异常的使用场景简单描述:Go中可以抛出一个panic的异常,然后在defer中通过recover捕获这个异常,然后正常处理

    panic(引发中断性错误):

    (1) 内置函数

    (2) 若函数中写了panic语句,则会终止其后要执行的代码

    (3) 直到整个goroutine退出,并报告错误

    recover:

    (1) 内置函数

    (2) 用来控制一个goroutine的panicking行为,捕获panic,从而影响应用的行为

    (3) 一般的调用建议

             a)在defer函数中,通过recover来终止一个goroutine的panicking过程,从而恢复正常代码的执行

             b)  可以获取通过panic传递的error

    注意:

    (1) 利用recover处理panic指令,defer必须放在panic之前定义,并且recover必须放在defer的函数中,否则不会影响panic的扩散

    (2) recover处理异常后,函数会恢复到defer之后的那个点

    error(表示函数调用状态):使用标准库errors.New和fmt.Errorf函数用于创建实现error接口的错误对象

    一个实例如下:

    package main
    
    import (
    	"errors"
    	"fmt"
    )
    
    var ErrDivByZero = errors.New("division by zero")
    
    func div(x, y int) (int, error) {
    	if y == 0 {
    		return 0, ErrDivByZero
    	}
    	return x / y, nil
    }
    func main() {
    	defer func() {
    		fmt.Println(recover())
    	}()
    	switch z, err := div(10, 0); err{
    	case nil:
    		println(z)
    	case ErrDivByZero:
    		panic(err)
    	}
    
    }
    

    运行结果:

    如何区别使用panic和error两种方式?

    一般来说,导致关键流程出现不可修复性错误的使用panic,其他使用error

     

    7. 单元测试

    Go语言中的测试依赖go test命令,在包目录内,所有以_test.go为后缀名的源代码文件都是go test测试的一部分,不会被go build编译到最终的可执行文件中。

    go test命令会遍历所有的*_test.go文件中符合上述命名规则的函数,然后生成一个临时的main包用于调用相应的测试函数,然后构建并运行、报告测试结果,最后清理测试中生成的临时文件

    Golang单元测试对文件名和方法名,参数都有很严格的要求:

    (1) 文件名必须以*_test.go命名

    (2) 方法必须是Test[^a-z]开头

    (3) 方法参数必须时 t *testing.T

    (4) 使用go test进行单元测试

     

     

    展开全文
  • 转载请注明出处,感谢您的支持。 文章来源:【chenyk的博客】http://blog.csdn.net/chenyk_kevin_1/article/details/79442045 Http请求模拟 1、新建线程组 操作:鼠标右键测试计划 -&gt; 添加 -&...
  • 压力测试

    2020-12-03 21:39:27
    固定接口参数进行压测还是进行接口参数随机化压测? 要求支持多少并发数? TPS(每秒钟处理事务数)目标多少?响应时间要达到多少? 压服务器名称还是压服务器IP,一般都是压测指定的服务器 压测设置 线程数:并发...
  • 通过结果信息来了解数据库的性能状况mysqlslap 的一个主要工作场景就是对数据库服务器做基准测试例如我们拿到了一台服务器,准备做为数据库服务器,那么这台服务器的硬件资源能够支持多大的访问压力呢?优化了操作...
  • 由于ADC0808支持8路信号采集,可以对8个压力参数进行检测。可以手动设置采集哪一路,或者循环采集。还可以进行压力上下限报警。 在设计系统的时候,立足于界面友好性、性价比,可以在简单压力检测的时候使用。
  • 初识压力测试

    2019-08-12 08:33:43
    压力测试 压力测试分两种场景:一种是单场景,压一个接口的;...固定接口参数进行压测还是进行接口参数随机化压测? 要求支持多少并发数? TPS(每秒钟处理事务数)目标多少?响应时间要达到多少? 压...
  • mysql应该i/o压力会比较大? 比如我定义两张表,连的都是同一个mysql server // 输入表test CREATE TABLE test ( idINT,nameVARCHAR(255),timeTIMESTAMP(3),status` INT, PRIMARY KEY(id) NOT ...
  • 通过结果信息来了解数据库的性能状况mysqlslap 的一个主要工作场景就是对数据库服务器做基准测试例如我们拿到了一台服务器,准备做为数据库服务器,那么这台服务器的硬件资源能够支持多大的访问压力呢?优化了操作...
  • 概述ab(Apache benchmark)是一款常用的压力...一、脚本说明 该脚本支持ab大多常用参数,如果你需要更多参数,可以通过修改本脚本,加入你想要的即可。该脚本支持:1)、批量测试。注意,并不是简单的批量测试,你可...
  • 压力测试知识说明

    2019-01-09 17:41:15
    压力测试知识说明 压力测试   压力测试分两种场景:一种是单场景,压一个接口的;...固定接口参数进行压测还是进行接口参数随机化压测? 要求支持多少并发数? TPS(每秒钟处理事务数)目标多少?响...
  • JMeter压力测试基础

    千次阅读 2017-03-28 17:43:53
    压力测试的目的是为系统模拟一个现实的访问场景,建立一堆线程去并发地访问系统,了解这个Web系统能支持多大的并发量,或者说支持多少用户同时在线而不会崩溃。我们通过调整并发的线程数,访问时间等参数,去了解在
  • Siege——压力测试

    2021-04-06 15:03:12
    可以对Web系统进行多并发下持续请求的压力测试。 安装Siege wget http://download.joedog.org/siege/siege-latest.tar.gz tar -xzvf siege-latest.tar.gz ./configure;make make install Siege命令常用参数 ...
  • Locust作为开源的压力测试工具,这几年备受关注,用法已经被大神们开发的差不多了。最近版本大更新,我重新学习一些基础用法,却发现参数化这一块的代码不能满足我的需求。所以这次我从一个小白的角度出发,争取用...
  • 贺德克 压力传感器 HDA3800pdf,该厂品为贺德克压力传感器HDA3800系列 资料中提供了该传感器的特性、各项参数、工作原理及其各项实验测量数据。同时还给出了该传感器使用的注意事项。为新的技术开发和使用者使用提供...
  • Web压力测试工具

    2016-03-17 22:30:20
    WEB应用与WEB服务的压力测试工具,使用.Net 2.0进行开发,支持.Net 3.0, 3.5, 4.0等后续.Net Framework版本, 测试工具为控制台应用程序,需要使用Windows系统的命令行工具启动程序,参数的设置可以根据程序提示查看...
  • webbench 压力测试软件

    2020-04-20 22:27:15
    1、安装 wget http://home.tiscali.cz/~cz...tar -xzvf webbench-1.5.tar.gz cd webbench-1.5 make && make install 3、参数 ...只支持get请求,可设定head参数 常用参数: -c 并发用户数 -t 压测时...
  • jmeter添加压力

    千次阅读 2019-03-25 16:57:17
    如果要5000个并发,但是你的电脑只支持2000个并发,那怎么办? 添加压力机 准备工作: 两台电脑可以互相ping通 配置文件里添加要一起压测的机子ip 他的电脑上要有jmeter,且他的电脑上运行jmeter-server 若有参数...
  • 压力测试的知识点

    2020-07-10 15:08:07
    1、压力测试分两种场景:一种是单场景,压一个接口的;第二种是混合场景,多个有关联的接口。压测时间,一般场景都运行10-15... 1)固定接口参数进行压测还是进行接口参数随机化压测? 2)要求支持多少并发数? 3)
  • 本身支持mysql数据库的压测。是业内最常用的数据库多线程基准测试工具,官方 1.0 版本发布以后,能够基于 lua 脚本进行定制测试,十分方便。二、安装yum安装:yum install sysbench三、参数说明sysbench 安装完成后...
  • 文章目录前言关注的参数响应时间tps出错率CPU、内存、队列、磁盘的使用情况设计并发场景查看压力测试结果结果分析非GUI模式的jmeter命令命令行进行测试命令行生成HTML报告查看HTML报告jmeter压力测试报告编写 ...
  • 例如我们拿到了一台服务器,准备做为数据库服务器,那么这台服务器的硬件资源能够支持多大的访问压力呢?优化了操作系统的内核参数后,是否提升了性能?调整了Mysql配置参数后,对性能有多少影响?…… 通过...
  • 通过结果信息来了解数据库的性能状况mysqlslap 的一个主要工作场景就是对数据库服务器做基准测试例如我们拿到了一台服务器,准备做为数据库服务器,那么这台服务器的硬件资源能够支持多大的访问压力呢?优化了操作...
  • dnsperf是我最近写的一个开源的DNS压力测试工具,用户可以用它来对DNS服务器或者Local DNS做压力测试。dnsperf目前的实现是单进程模式...Dnsperf 支持下面的这些命令行参数: -s 用来指定DNS服务器的IP地址,默认值...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 478
精华内容 191
关键字:

压力支持参数