环境：mysql8.0

基准测试简介

1、什么是基准测试

数据库的基准测试是对数据库的性能指标进行定量的、可复现的、可对比的测试。

基准测试与压力测试

基准测试可以理解为针对系统的一种压力测试。但基准测试不关心业务逻辑，更加简单、直接、易于测试，数据可以由工具生成，不要求真实；而压力测试一般考虑业务逻辑(如购物车业务)，要求真实的数据。

2、基准测试的作用

对于多数Web应用，整个系统的瓶颈在于数据库；原因很简单：Web应用中的其他因素，例如网络带宽、负载均衡节点、应用服务器（包括CPU、内存、硬盘灯、连接数等）、缓存，都很容易通过水平的扩展（俗称加机器）来实现性能的提高。而对于MySQL，由于数据一致性的要求，无法通过增加机器来分散向数据库写数据带来的压力；虽然可以通过前置缓存（Redis等）、读写分离、分库分表来减轻压力，但是与系统其它组件的水平扩展相比，受到了太多的限制。

而对数据库的基准测试的作用，就是分析在当前的配置下（包括硬件配置、OS、数据库设置等），数据库的性能表现，从而找出MySQL的性能阈值，并根据实际系统的要求调整配置。

3、基准测试的指标

常见的数据库指标包括：

TPS/QPS：衡量吞吐量。
响应时间：包括平均响应时间、最小响应时间、最大响应时间、时间百分比等，其中时间百分比参考意义较大，如前95%的请求的最大响应时间。。
并发量：同时处理的查询请求的数量。

(root@localhost) [(none)]> show global status like '%question%'; 
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Questions     | 4     |
+---------------+-------+
1 row in set (0.04 sec)

(root@localhost) [(none)]> show global status like '%uptime%';  --服务器启动到现在的结果
+---------------------------+-------+
| Variable_name             | Value |
+---------------------------+-------+
| Uptime                    | 47    |
| Uptime_since_flush_status | 47    |
+---------------------------+-------+
2 rows in set (0.00 sec)

(root@localhost) [(none)]> status
--------------
mysql  Ver 8.0.15 for linux-glibc2.12 on x86_64 (MySQL Community Server - GPL)

Connection id:		8
Current database:	
Current user:		root@localhost
SSL:			Cipher in use is DHE-RSA-AES128-GCM-SHA256
Current pager:		stdout
Using outfile:		''
Using delimiter:	;
Server version:		8.0.15 MySQL Community Server - GPL
Protocol version:	10
Connection:		localhost via TCP/IP
Server characterset:	utf8mb4
Db     characterset:	utf8mb4
Client characterset:	utf8mb4
Conn.  characterset:	utf8mb4
TCP port:		3306
Uptime:			2 min 14 sec

Threads: 2  Questions: 9  Slow queries: 0  Opens: 126  Flush tables: 2  Open tables: 102  Queries per second avg: 0.067
--------------

4、基准测试的分类

对MySQL的基准测试，有如下两种思路：

（1）针对整个系统的基准测试：通过http请求进行测试，如通过浏览器、APP或postman等测试工具。该方案的优点是能够更好的针对整个系统，测试结果更加准确；缺点是设计复杂实现困难。
（2）只针对MySQL的基准测试：优点和缺点与针对整个系统的测试恰好相反。

在针对MySQL进行基准测试时，一般使用专门的工具进行，例如mysqlslap、sysbench等。其中，sysbench比mysqlslap更通用、更强大，且更适合Innodb（因为模拟了许多Innodb的IO特性），下面介绍使用sysbench进行基准测试的方法。
以上转载自：http://www.cnblogs.com/kismetv/p/7615738.html

sysbench

1、sysbench简介

sysbench支持以下几种测试模式：

1、CPU运算性能
2、磁盘IO性能
3、调度程序性能
4、内存分配及传输速度
5、POSIX线程性能
6、数据库性能(OLTP基准测试)

2、sysbench安装

环境：ubuntu18.04

apt-get安装

$ sudo apt-get install sysbench

git 安装【不推荐，太慢了】

1、下载

$ git clone "https://github.com/akopytov/sysbench"
$ cd sysbench/
$ ls
autogen.sh  ChangeLog  config  configure.ac  COPYING  debian  install-sh  m4  Makefile.am  missing  mkinstalldirs  README.md  rpm  scripts  snap  src  tests  third_party
$ cat README.md

2、安装依赖

$ sudo apt -y install make automake libtool pkg-config libaio-dev 
$ sudo apt -y install libmysqlclient-dev libssl-dev

3、安装sysbench

$ ./autogen.sh 
-- 如果mysql不是安装在默认路径下，那么需要配置
$ ./configure  --prefix=/home/ocean/workspace/mysql/sysbench/install  --with-mysql-includes=/usr/local/mysql/include --with-mysql-libs=/usr/local/mysql/lib --with-mysql       
# 另外指定安装目录则用下面这个
#--prefix=/usr/sysbench/                    # 指定sysbench的安装目录。
#--with-mysql-includes=/usr/include/mysql/  # 指定安装mysql时候的includes目录。
#--with-mysql-libs=/usr/lib/mysql/          # 指定装mysql时候的lib目录。
# --with-mysql                               #sysbench默认支持mysql，如果需要测试oracle或者pgsql则需要制定–with-oracle或者–with-pgsql。 
$ sudo make -j4
$ sudo make install 
$ export PATH=$PATH:/home/ocean/workspace/mysql/sysbench/install/bin # 注意，如果prefix手动指定了sysbench的安装目录，请添加环境变量

4、测试是否安装成功

$ sysbench --version
sysbench: error while loading shared libraries: libmysqlclient.so.21: cannot open shared object file: No such file or directory
$ locate libmysqlclient.so.21
/usr/local/mysql/lib/libmysqlclient.so.21
$ sudo gedit /etc/ld.so.conf
/usr/local/mysql/lib   --保存退出
$ sudo ldconfig
$ sysbench --version
sysbench 1.1.0-18a9f86

3、sysbench语法

查看 sysbench 的可用命令、选项及內建测试类型的帮助信息

$  sysbench --help
Usage:
  sysbench [options]... [testname] [command]

testname

[testname] 是内置测试的可选名称( 比如。 fileio，memory，cpu，等等 ) 或者一个绑定的Lua脚本的名称( 比如。 oltp_read_only )，或者是特定于自定义的Lua脚本的路径。如果没有在命令行 ( 因此，没有命令，因为在这种情况下，它将被解析为一个 testname ) 上指定测试名，或者者测试名称是一个错误的(" -")，则on会在它的标准输入中执行。

command

[command] 是一个可选参数，它将由sysbench传递给用testname指定的测试或者脚本。命令定义动作必须由测试执行。可用命令的列表取决于特定的测试。一些测试还实现了自己的定制命令。

* 下面是典型测试命令的说明及其用途：
     * prepare:测试前准备工作，比如 为 fileio 测试创建必要的文件，或者者填充数据库测试数据库。
     * run: 正式测试。
     * cleanup: 测试后删掉测试数据 
     * help: 显示使用 testname 参数指定的测试的用法信息。 这包括测试提供的完整命令列表，因此应该使用它来获取可用命令。

options

[options] 是从 ‘–’ 开始的零或者更多命令行选项的列表。
sysbench的参数有很多，其中比较常用的包括：

>* --threads：客户端的并发连接数，默认 1 个
> * --events	=N请求总数的限制。 0 ( 默认值) 表示无限制	 
 >* --time：测试执行的时间，单位是秒，该值不要太短，可以选择120, 0表示无限制	，默认10.
>* oltp-test-mode：执行模式，包括simple、nontrx和complex，默认是complex。simple模式下只测试简单的查询；nontrx不仅测试查询，还测试插入更新等，但是不使用事务；complex模式下测试最全面，会测试增删改查，而且会使用事务。可以根据自己的需要选择测试模式。
>* oltp-tables-count：测试的表数量，根据实际情况选择
>* oltp-table-size：测试的表的大小，根据实际情况选择
>* report-interval：生成报告的时间间隔，单位是秒，如10

debug[=on|off] 是否打印更多调试信息。默认是off

help[=on|off]：是否打印帮助信息。 [off]

version[=on|off] ：是否打印版本信息。[off]

validate[=on|off] ：在可能情况下执行验证检查。默认是off。

forced-shutdown=STRING ：在 --time 时间限制到达后，强制关闭之前等待的秒数，默认“off”禁用

thread-stack-size=SIZE ：每个线程的堆栈大小。默认是[64K]

report-interval=N：以秒为单位定期报告中间统计信息。注意，这里选项生成的统计信息是间隔而不是累积的。 0禁用中间报告

4、sysbench测试注意事项与建议

注意事项

（1）尽量不要在MySQL服务器运行的机器上进行测试，一方面可能无法体现网络（哪怕是局域网）的影响，另一方面，sysbench的运行（尤其是设置的并发数较高时）会影响MySQL服务器的表现。

（2）可以逐步增加客户端的并发连接数（–thread参数），观察在连接数不同情况下，MySQL服务器的表现；如分别设置为10,20,50,100等。

（3）一般执行模式选择complex即可，如果需要特别测试服务器只读性能，或不使用事务时的性能，可以选择simple模式或nontrx模式。

（4）如果连续进行多次测试，注意确保之前测试的数据已经被清理干净。

使用建议

（1）在开始测试之前，应该首先明确：应采用针对整个系统的基准测试，还是针对MySQL的基准测试，还是二者都需要。

（2）如果需要针对MySQL的基准测试，那么还需要明确精度方面的要求：是否需要使用生产环境的真实数据，还是使用工具生成也可以；前者实施起来更加繁琐。如果要使用真实数据，尽量使用全部数据，而不是部分数据。

（3）基准测试要进行多次才有意义。

（4）测试时需要注意主从同步的状态。

（5）测试必须模拟多线程的情况，单线程情况不但无法模拟真实的效率，也无法模拟阻塞甚至死锁情况。

5、sysbench使用例子

性能(CPU)测试

测试计算素数对这个数字除以 2 到这个数字平方根之间的所有数字来验证素数）直到某个最大值所需要的时间
CPU 基准测试时可以指定线程数量和素数上限。性能测试【找范围内最大素数{时间越短越好}】

$ sysbench  cpu help
--cpu-max-prime=N  最大质数发生器数量。默认是10000

--threads
$ sysbench cpu --cpu-max-prime=10000 --report-interval=1 run   -- cpu到底20000时所需要的时间
 Running the test with following options:
Number of threads: 1           -- 线程数，一般指定为CPU核数就可以,比如 --threads=2 
Initializing random number generator from current time

Prime numbers limit: 10000

Initializing worker threads...

Threads started!

CPU speed:
    events per second:  1355.07   -- 每一秒事件数

Throughput:
    events/s (eps):                      1355.0670
    time elapsed:                        10.0002s      -- 所有时间 【越小越优秀】
    total number of events:              13551    -- 全部事件数量

Latency (ms):   --等待事件
         min:                                    0.69
         avg:                                    0.74
         max:                                    3.79
         95th percentile:                        0.84   -- 前95%的请求的最大响应时间
         sum:                                 9991.89

Threads fairness:
    events (avg/stddev):           13551.0000/0.00
    execution time (avg/stddev):   9.9919/0.00

$ sysbench cpu  --threads=2  --cpu-max-prime=20000  --report-interval=1  run

线程(thread)测试

测试线程调度器的性能。对于高负载情况下测试线程调度器的行为非常有用。
多核性能，线程调度线程并发执行，循环响应信号量花费的时间
线程调度【线程并发执行，循环响应信号量花费的时间{越少越好}】

$ sysbench  threads help

sysbench 1.1.0-18a9f86 (using bundled LuaJIT 2.1.0-beta3)

threads options:
  --thread-yields=N   每个请求产生多少个线程。默认是1000
  --thread-locks=N    每个线程的锁的数量。默认是8

$  sysbench threads --threads=2 --report-interval=1  run

互斥锁(mutex)测试

并发线程同时申请互斥锁循环一定次数花费的时间测试互斥锁的性能
方式是模拟所有线程在同一时刻并发运行，并都短暂请求互斥锁。
互斥锁【并发线程同时申请互斥锁循环一定次数花费的时间{越少越好}】

$ sysbench mutex help
sysbench 1.1.0-18a9f86 (using bundled LuaJIT 2.1.0-beta3)

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 outside mutex lock [10000]

sysbench mutex --threads=2 --mutex-locks=1000000  --report-interval=1  run

内存(memory)测试

以不同块大小传输一定数量的数据,测试内存读写性能
内存【以不同块大小传输一定数量的数据吞吐量大小{越大越好}】

$ sysbench  memory help
sysbench 1.1.0-18a9f86 (using bundled LuaJIT 2.1.0-beta3)

memory options:
  --memory-block-size=SIZE  测试时内存块大小。默认是1K
  --memory-total-size=SIZE    传输数据的总大小。默认是100G
  --memory-scope=STRING    内存访问范围{global,local}。默认是global
  --memory-hugetlb=[on|off]  从HugeTLB池内存分配。默认是off
  --memory-oper=STRING     内存操作类型。{read, write, none} 默认是write
  --memory-access-mode=STRING存储器存取方式{seq,rnd} 默认是seq

sysbench memory --memory-block-size=8K --memory-total-size=1G  --threads=16 run

文件IO(fileio)测试

测试系统在不同IO负载下的IOPS性能，IO【不同场景下IOPS{越大越好}

# sysbench  fileio help
sysbench 0.4.12:  multi-threaded system evaluation benchmark

fileio options:
  --file-num=N   创建测试文件的数量。默认是128
  --file-block-size=N  测试时文件块的大小。默认是16384(16K)
  --file-total-size=SIZE   测试文件的总大小。默认是2G
  --file-test-mode=STRING  文件测试模式{seqwr(顺序写), seqrewr(顺序读写), seqrd(顺序读), rndrd(随机读), rndwr(随机写), rndrw(随机读写)}
  --file-io-mode=STRING   文件操作模式{sync(同步),async(异步),fastmmap(快速map映射),slowmmap(慢map映射)}。默认是sync
  --file-async-backlog=N        number of asynchronous operatons to queue per thread [128]
  --file-extra-flags=STRING   使用额外的标志来打开文件{sync,dsync,direct} 。默认为空
  --file-fsync-freq=N   执行fsync()的频率。(0 – 不使用fsync())。默认是100
  --file-fsync-all=[on|off] 每执行完一次写操作就执行一次fsync。默认是off
  --file-fsync-end=[on|off] 在测试结束时才执行fsync。默认是on
  --file-fsync-mode=STRING  使用哪种方法进行同步{fsync, fdatasync}。默认是fsync
  --file-merged-requests=N   如果可以，合并最多的IO请求数(0 – 表示不合并)。默认是0
  --file-rw-ratio=N     测试时的读写比例。默认是1.5

使用 fileio 时，需要创建一组测试文件，测试文件需要大于可用内存的大小，避免文件缓存在内存中影响结果。测试流程为：准备测试文件-》测试-》回收测试文件，命令如下：

$  sysbench --file-num=4 --file-test-mode=rndrw --time=300 --threads=8  fileio run
sysbench 1.1.0-18a9f86 (using bundled LuaJIT 2.1.0-beta3)

Running the test with following options:
Number of threads: 8
Initializing random number generator from current time


Extra file open flags: (none)
4 files, 512MiB each
2GiB total file size                --测试文件的总大小。默认是2G
Block size 16KiB                    -- 不指定则默认16K
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50    测试时的读写比例。默认是1.5
Periodic FSYNC enabled, calling fsync() each 100 requests. --定期启用fsync，每100个请求调用fsync（）。
Calling fsync() at the end of test, Enabled.  --在测试结束时调用fsync（），已启用
Using synchronous I/O mode   --使用同步I/O模式
Doing random r/w test   --做随机R/W测试
Initializing worker threads...   --正在初始化工作线程

Threads started!

Throughput:
         read:  IOPS=160.70 2.51 MiB/s (2.63 MB/s)
         write: IOPS=107.13 1.67 MiB/s (1.76 MB/s)
         fsync: IOPS=10.81

Latency (ms):
         min:                                  0.00
         avg:                                 28.64
         max:                               3686.64
         95th percentile:                    200.47
         sum:                            2401434.45
$ $ sysbench --file-num=4 --file-test-mode=rndrd --time=5 --threads=8  --file-extra-flags=direct fileio --report-interval=1 run
sysbench 1.1.0-18a9f86 (using bundled LuaJIT 2.1.0-beta3)

Running the test with following options:
Number of threads: 8
Report intermediate results every 1 second(s)
Initializing random number generator from current time

Extra file open flags: directio
4 files, 512MiB each
2GiB total file size
Block size 16KiB
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 100 requests.

Threads started!

[ 1s ] reads: 2.12 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 170.479
[ 2s ] reads: 2.58 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 134.899
[ 3s ] reads: 2.47 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 164.449
[ 4s ] reads: 2.26 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 158.632
[ 5s ] reads: 2.55 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 132.492

Throughput:
         read:  IOPS=153.18 2.39 MiB/s (2.51 MB/s)
         write: IOPS=0.00 0.00 MiB/s (0.00 MB/s)
         fsync: IOPS=0.00

Latency (ms):
         min:                                  0.72
         avg:                                 51.87
         max:                               1304.13
         95th percentile:                    161.51
         sum:                              40200.52

$ sysbench fileio  --file-num=4 --file-block-size=4096 --file-total-size=2G --file-test-mode=rndrd --file-extra-flags=direct --time=10  --file-fsync-freq=1 --threads=8 --report-interval=1 run 

[ 1s ] reads: 0.49 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 267.408
[ 2s ] reads: 0.62 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 179.942
[ 3s ] reads: 0.68 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 132.492
[ 4s ] reads: 0.70 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 114.717
[ 5s ] reads: 0.66 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 153.021
[ 6s ] reads: 0.34 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 253.346
[ 7s ] reads: 0.66 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 139.846
[ 8s ] reads: 0.67 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 137.350
[ 9s ] reads: 0.62 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 167.437
[ 10s ] reads: 0.60 MiB/s writes: 0.00 MiB/s fsyncs: 0.00/s latency (ms,95%): 176.731

Throughput:
         read:  IOPS=154.09 0.60 MiB/s (0.63 MB/s)
         write: IOPS=0.00 0.00 MiB/s (0.00 MB/s)
         fsync: IOPS=0.00

$ sysbench fileio  --file-num=4 --file-block-size=4096 --file-total-size=2G --file-test-mode=rndrw --file-extra-flags=direct --time=10  --file-fsync-freq=1 --threads=8 --report-interval=1 run             # --time=10一般选择300ms
sysbench 1.1.0-18a9f86 (using bundled LuaJIT 2.1.0-beta3)

Running the test with following options:
Number of threads: 128
Report intermediate results every 1 second(s)
Initializing random number generator from current time


Extra file open flags: directio
4 files, 512MiB each
2GiB total file size
Block size 4KiB
Number of IO requests: 0

Threads started!

[ 1s ] reads: 0.26 MiB/s writes: 0.00 MiB/s fsyncs: 16.88/s latency (ms,95%): 926.327
[ 2s ] reads: 0.20 MiB/s writes: 0.09 MiB/s fsyncs: 439.51/s latency (ms,95%): 1561.523
[ 3s ] reads: 0.11 MiB/s writes: 0.21 MiB/s fsyncs: 107.75/s latency (ms,95%): 2238.469
[ 4s ] reads: 0.18 MiB/s writes: 0.23 MiB/s fsyncs: 36.05/s latency (ms,95%): 1903.575
[ 5s ] reads: 0.33 MiB/s writes: 0.22 MiB/s fsyncs: 386.61/s latency (ms,95%): 1869.605
[ 6s ] reads: 0.29 MiB/s writes: 0.22 MiB/s fsyncs: 135.03/s latency (ms,95%): 816.626
[ 7s ] reads: 0.25 MiB/s writes: 0.13 MiB/s fsyncs: 137.43/s latency (ms,95%): 1352.033
[ 8s ] reads: 0.36 MiB/s writes: 0.22 MiB/s fsyncs: 239.21/s latency (ms,95%): 2405.646
[ 9s ] reads: 0.41 MiB/s writes: 0.26 MiB/s fsyncs: 288.79/s latency (ms,95%): 1973.377
[ 10s ] reads: 0.32 MiB/s writes: 0.23 MiB/s fsyncs: 231.76/s latency (ms,95%): 1352.033
[ 11s ] reads: 0.09 MiB/s writes: 0.09 MiB/s fsyncs: 192.27/s latency (ms,95%): 2362.716

Throughput:
         read:  IOPS=65.41 0.26 MiB/s (0.27 MB/s)
         write: IOPS=43.63 0.17 MiB/s (0.18 MB/s)
         fsync: IOPS=215.36

Latency (ms):
         min:                                  0.00
         avg:                                436.16
         max:                               2615.18
         95th percentile:                   1903.57
         sum:                            1440194.65
$ sysbench --file-total-size=2G --file-num=4 fileio cleanup  
------------------
$ sysbench --test=fileio --file-num=4 --file-block-size=16384 --file-total-size=2G prepare -- 测试由4个文件组成,测试块是16K一块
$ sysbench fileio  --file-num=4 --file-block-size=4096 --file-total-size=2G --file-test-mode=rndrw --file-extra-flags=direct --time=300  --file-fsync-freq=1 --threads=128 --report-interval=1 run
 --time 表示测试300s
--num-threads 测试线程
--report-interval=1 每秒输出结果

[ 108s ] reads: 0.45 MiB/s writes: 0.32 MiB/s fsyncs: 352.85/s latency (ms,95%): 2320.552
[ 109s ] reads: 0.43 MiB/s writes: 0.38 MiB/s fsyncs: 479.79/s latency (ms,95%): 1032.013
[ 110s ] reads: 0.50 MiB/s writes: 0.13 MiB/s fsyncs: 152.16/s latency (ms,95%): 1352.033
[ 111s ] reads: 0.16 MiB/s writes: 0.27 MiB/s fsyncs: 167.87/s latency (ms,95%): 2279.141
[ 112s ] reads: 0.57 MiB/s writes: 0.33 MiB/s fsyncs: 402.98/s latency (ms,95%): 1069.856

File operations:
    reads/s:                      95.32
    writes/s:                     63.49
    fsyncs/s:                     253.95

Throughput:
    read, MiB/s:                  0.37
    written, MiB/s:               0.25

General statistics:
    total time:                          301.2547s
    total number of events:              124345

Latency (ms):
         min:                                  0.00
         avg:                                309.69
         max:                               3728.20
         95th percentile:                   1648.20
         sum:                            38508863.48

Threads fairness:
    events (avg/stddev):           971.4453/47.81
    execution time (avg/stddev):   300.8505/0.29

MYSQL性能(oltp)测试

我的版本好像无法oltp测试

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

https://blog.csdn.net/joeson7456/article/details/80749149#sysbench-之-mysql语法
sysbench 通过一系列LUA脚本来替换之前的oltp，来模拟更接近真实的基准测试环境。这些测试脚本包含：

~/workspace/mysql/sysbench/install/share/sysbench$ ls
bulk_insert.lua  oltp_insert.lua        oltp_read_write.lua        oltp_write_only.lua       tests
oltp_common.lua  oltp_point_select.lua  oltp_update_index.lua      select_random_points.lua
oltp_delete.lua  oltp_read_only.lua     oltp_update_non_index.lua  select_random_ranges.lua

各脚本使用方式基本类似。

MySQL连接信息参数
- mysql-host：MySQL服务器主机名，默认localhost；如果在本机上使用localhost报错，提示无法连接MySQL服务器，改成本机的IP地址应该就可以了。
- mysql-port：MySQL服务器端口，默认3306
- mysql-user：用户名
- mysql-password：密码
- mysql-db=STRING MySQL database name [sbtest]

等等

mysqladmin

1、mysqladmin简介

mysqladmin是一个执行管理操作的客户端程序。它可以用来检查服务器的配置和当前状态、创建和删除数据库等。

官方链接

2、mysqladmin使用

~$  mysqladmin -uroot -p -i 2 -c 5 status --每两秒查看一次服务器的状态，总共重复5次。
Enter password: 
Uptime: 1328  Threads: 2  Questions: 15  Slow queries: 0  Opens: 126  Flush tables: 2  Open tables: 102  Queries per second avg: 0.011
$ mysqladmin -uroot -p status  --查看服务器的状况：status
Enter password: 
Uptime: 1397  Threads: 2  Questions: 21  Slow queries: 0  Opens: 126  Flush tables: 2  Open tables: 102  Queries per second avg: 0.015
$ mysqladmin -u root -p原密码 password 'newpassword' --修改密码
mysqladmin: [Warning] Using a password on the command line interface can be insecure.
Warning: Since password will be sent to server in plain text, use ssl connection to ensure password safety.
$ mysqladmin -uroot -p ping --检查mysqlserver是否可用
$ mysqladmin -uroot -p version --查询服务器的版本
$ mysqladmin -uroot -p extended-status --查看服务器状态的当前值
$ mysqladmin -uroot -p variables  --查询服务器系统变量值
$ mysqladmin -uroot -p processlist  显示服务器所有运行的进程
$ mysqladmin -uroot -p-i 1 processlist        //每秒刷新一次
$ mysqladmin -uroot -p create daba-test  --创建数据库
$ mysqlshow -uroot -p  --显示服务器上的所有数据库
$ mysqlshow -uroot -p daba-test --显示数据库daba-test下有些什么表
$ mysqlshow -uroot -p daba-test -v  --统计daba-test 下数据库表列的汇总
$ mysqlshow -uroot -p daba-test -v -v --统计daba-test 下数据库表的列数和行数
$ mysqladmin -uroot -p drop daba-test  --删除数据库 daba-test
$ mysqladmin -uroot -p reload  --重载权限信息
$ mysqladmin -uroot -p refresh  --刷新所有表缓存，并关闭和打开log
$ mysqladmin -uroot -p shutdown  --使用安全模式关闭数据库
-- 刷新命令mysqladmin flush commands
# mysqladmin -u root -ptmppassword flush-hosts  --清空主机相关的缓存，包括：DNS解析缓存、连接错误次数过多而被拒绝访问mysqld的主机等
# mysqladmin -u root -ptmppassword flush-logs  --关闭日志，打开新日志对二进制、中继日志进行滚动
# mysqladmin -u root -ptmppassword flush-privileges -- 刷新配置
# mysqladmin -u root -ptmppassword flush-status  --重置状态变量
# mysqladmin -u root -ptmppassword flush-tables  --关闭当前打开的表文件句柄
# mysqladmin -u root -ptmppassword flush-threads
--  mysqladmin 执行kill 进程：
# mysqladmin -uroot -p processlist
# mysqladmin -uroot -p kill idnum

-- 停止和启动MySQL replication on a slave server
# mysqladmin -u root -p stop-slave
# mysqladmin -u root -p start-slave

-- 同时执行多个命令
# mysqladmin -u root -p process status version
$ mysqladmin extended-status -uroot -p -r -i 1 | grep -i Question  -- 查看IPS
$ top

vmstat

$ vmstat 5;   --每隔5s打印一个报告
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  0 483328 218964 130648 723596    1    4    26    50   82  138  2  2 95  0  0
 0  0 483328 218964 130656 723596    0    0     0    10  382  842  0  1 99  0  0
 0  0 483328 218964 130664 723588    0    0     0     6  364  882  0  1 99  0  0

proc：
- r：显示有多少进程正在等待CPU
- b：显示多少进程正在不可以中断地休眠[通常意味它们在等待I/O，例如磁盘，网络，用户输入等等]
memory
- swpd：有多少块被切换出了磁盘[页面交换]
- free ：未被使用地块
- buff ：被用作缓冲地快
- cache：被用作操作系统缓存地块
swap：页面交换
- si：每秒有多少块正在被换入磁盘
- so：每秒有多少块正在被换出磁盘
- si与so为0性能最好，最好不要每秒超过10块，不要有突发性地高峰
io：反映了硬盘IO
- bi：显示有多少块从块设备读取
- bo：显示有多少块从块设备写入
system：
- in：显示每秒中断次数
- cs ：显示每秒上下文切换次数[当OS停止一个化进程转而运行另一个进程时]—》最好不要超过100 000次
cpu：所有的CPU时间花费在各类操作的百分百
- us ：执行用户代码
- sy：执行内核代码—>CPU的利用率，最好不要超过20%
- id：空闲
- wa：等待IO
- st：如果在虚拟机中就有，表示虚拟机想要运行但是系统管理查询转而运行其他的对象的时间。

iostat

$ sudo apt install sysstat
$ iostat -xm 3 # x表示显示扩展统计信息，m表示以兆为单位显示，3表示每隔3秒显示\
Linux 4.18.0-13-generic (ubuntu) 	01/24/2019 	_x86_64_	(2 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
           2.19    0.02    2.10    0.43    0.00   95.26

Device            r/s     w/s     rMB/s     wMB/s   rrqm/s   wrqm/s  %rrqm  %wrqm r_await w_await aqu-sz rareq-sz wareq-sz  svctm  %util
loop0            0.01    0.00      0.00      0.00     0.00     0.00   0.00   0.00    0.92    0.00   0.00     1.19     0.00   1.01   0.00
loop1            0.00    0.00      0.00      0.00     0.00     0.00   0.00   0.00   27.32    0.00   0.00     2.60     0.00  27.06   0.00
loop2            0.25    0.00      0.00      0.00     0.00     0.00   0.00   0.00    5.52    0.00   0.00     1.04     0.00   0.29   0.01
loop3            0.02    0.00      0.00      0.00     0.00     0.00   0.00   0.00    0.30    0.00   0.00     1.12     0.00   0.36   0.00

CPU属性	说明
%user	CPU处在用户模式下的时间百分比
%nice	CPU处在带NICE值的用户模式下的时间百分比
%sys	CPU处在系统模式下的时间百分比
%iowait	CPU等待IO完成时间的百分比
%steal	管理程序维护另一个虚拟处理器时，虚拟CPU的无意的等待时间的百分比
%idle	闲置cpu的百分比

提示：

如果%iowait的值过高，表示硬盘存在I/O瓶颈;
如果%idle值高，表示CPU较空闲，如果%idle值高但系统响应慢时，有可能是CPU* 等待分配内存，此时应加大内存容量。
如果%idle值如果持续很低，那么系统的CPU处理能力相对较低，表明系统中最需要解决的资源是CPU。

Device属性	说明
rrqm/s	每秒进行合并的读操作数目
wrqm/s	每秒进行合并的的写操作数目
r/s	每秒完成的读 I/O 设备次数
w/s	每秒完成的写 I/O 设备次数
rsec/s	每秒读扇区数
wsec/s	每秒写扇区数
rkB/s	每秒读K字节数
wkB/s	每秒写K字节数
avgrq-sz	平均每次设备I/O操作的数据大小 (请求的扇区数)
avgqu-sz	平均I/O队列长度(在设备队列中等待的请求数)
await	平均每次设备I/O操作的等待时间 (毫秒)–>磁盘排队上花费的毫秒数
svctm	平均每次设备I/O操作的服务时间 (毫秒)–>服务请求花费的毫秒数
%util	一秒中有百分之多少的时间用于 I/O 操作，即被io消耗的cpu百分比

设备服务请求的并发数：(r/s+w/s)*(svctm/1000) = (avgqu-sz * svctm)/await
提示：

如果 %util 接近 100%，说明产生的I/O请求太多，I/O系统已经满负荷，该磁盘可能存在瓶颈。
如果 svctm 比较接近 await，说明 I/O 几乎没有等待时间；
如果 await 远大于 svctm，说明I/O队列太长，io响应太慢，则需要进行必要优化。
如果avgqu-sz比较大，也表示有当量io在等待。

参考：https://blog.csdn.net/kikajack/article/details/79977108
参考：http://www.cnblogs.com/kismetv/p/7615738.html
参考：https://wiki.gentoo.org/wiki/Sysbench
参考：https://blog.csdn.net/joeson7456/article/details/80749149
参考：https://blog.51cto.com/itest/1737682
参考：https://blog.51cto.com/13214087/2140038
参考：https://blog.csdn.net/joeson7456/article/details/80749149#sysbench-之-mysql语法
参考：https://www.cnblogs.com/sykblogs/p/9381382.html
参考：<高性能MYSQL>

MYSQL系列(53)：数据库基准测试与mysqladmn监控