Redis学习2之redis-benchmark使用方法总结

最新推荐文章于 2024-06-19 18:17:06 发布
最新推荐文章于 2024-06-19 18:17:06 发布
阅读量4.8k 收藏 4
点赞数
分类专栏： redis NoSQL 文章标签： redis nosql 安装和使用 redis-benchmark 使用方法总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xubo245/article/details/48320689
版权
NoSQL 同时被 2 个专栏收录
24 篇文章 0 订阅
订阅专栏
redis
13 篇文章 0 订阅
订阅专栏

redis-benchmark使用方法总结：包括各个指令的详细解释。

redis-3.0.4

1.redis-benchmark -help  

hadoop@Master:~$ redis-benchmark -help
Invalid option "-help" or option argument missing

Usage: redis-benchmark [-h <host>] [-p <port>] [-c <clients>] [-n <requests]> [-k <boolean>]

 -h <hostname>      Server hostname (default 127.0.0.1)                    //服务主机名
 -p <port>          Server port (default 6379)                             //服务器端口号
 -s <socket>        Server socket (overrides host and port)                //socket，覆盖host和port
 -a <password>      Password for Redis Auth                                //密码
 -c <clients>       Number of parallel connections (default 50)            //并行请求的客户端数量，默认50
 -n <requests>      Total number of requests (default 100000)              //请求的总量，默认100000
 -d <size>          Data size of SET/GET value in bytes (default 2)        //set或get的数据尺寸，单位是字节，默认是2
 -dbnum <db>        SELECT the specified db number (default 0)             //选择指定的数据号
 -k <boolean>       1=keep alive 0=reconnect (default 1)                   //布尔量，1代表保持活跃，0代表重连
 -r <keyspacelen>   Use random keys for SET/GET/INCR, random values for SADD //set/get/incr使用随机的keys,SADD使用随机值...
  Using this option the benchmark will expand the string __rand_int__
  inside an argument with a 12 digits number in the specified range
  from 0 to keyspacelen-1. The substitution changes every time a command
  is executed. Default tests use this to hit random keys in the
  specified range.
 -P <numreq>        Pipeline <numreq> requests. Default 1 (no pipeline).    //管道请求，默认是1，没管道（并行？）
 -q                 Quiet. Just show query/sec values                       //安静，仅仅展示每秒的查询值
 --csv              Output in CSV format                                    //输出按CSV格式
 -l                 Loop. Run the tests forever
 -t <tests>         Only run the comma separated list of tests. The test    //仅仅运行tests
                    names are the same as the ones produced as output.
 -I                 Idle mode. Just open N idle connections and wait.       //闲置模型，进打开N个闲置链接且等待

Examples:

 Run the benchmark with the default configuration against 127.0.0.1:6379:
   $ redis-benchmark

 Use 20 parallel clients, for a total of 100k requests, against 192.168.1.1:
   $ redis-benchmark -h 192.168.1.1 -p 6379 -n 100000 -c 20

 Fill 127.0.0.1:6379 with about 1 million keys only using the SET test:
   $ redis-benchmark -t set -n 1000000 -r 100000000

 Benchmark 127.0.0.1:6379 for a few commands producing CSV output:
   $ redis-benchmark -t ping,set,get -n 100000 --csv

 Benchmark a specific command line:
   $ redis-benchmark -r 10000 -n 10000 eval 'return redis.call("ping")' 0

 Fill a list with 10000 random elements:
   $ redis-benchmark -r 10000 -n 10000 lpush mylist __rand_int__

 On user specified command lines __rand_int__ is replaced with a random integer
 with a range of values selected by the -r option.

自己看下就能明白意思。

下面简单抛下：

2.直接测试redis-benchmark：

hadoop@Master:~$ redis-benchmark 
====== PING_INLINE ======
  100000 requests completed in 0.81 seconds     //默认是100000，上面有，请求在0.81s内完成
  50 parallel clients                           //50个客户端并行操作
  3 bytes payload                               //每次写入3个字节的数据
  keep alive: 1                                 //保持一个连接，一台服务器来处理这些请求  ？？未验证是一个服务器还是一个实例？？

99.86% <= 1 milliseconds
99.97% <= 3 milliseconds
100.00% <= 3 milliseconds
123609.39 requests per second 

====== PING_BULK ======
  100000 requests completed in 0.80 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.81% <= 1 milliseconds
99.88% <= 2 milliseconds
100.00% <= 2 milliseconds
124378.11 requests per second

====== SET ======
  100000 requests completed in 0.87 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.33% <= 1 milliseconds
99.95% <= 5 milliseconds
100.00% <= 5 milliseconds
115340.26 requests per second

====== GET ======
  100000 requests completed in 0.80 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.90% <= 2 milliseconds
99.95% <= 3 milliseconds
100.00% <= 3 milliseconds
124688.28 requests per second

====== INCR ======
  100000 requests completed in 0.79 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.85% <= 1 milliseconds
99.86% <= 2 milliseconds
99.95% <= 3 milliseconds
100.00% <= 3 milliseconds
126582.27 requests per second

====== LPUSH ======
  100000 requests completed in 0.79 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.90% <= 2 milliseconds
99.91% <= 3 milliseconds
99.95% <= 4 milliseconds
100.00% <= 4 milliseconds
126262.62 requests per second

====== LPOP ======
  100000 requests completed in 0.79 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.90% <= 1 milliseconds
99.95% <= 2 milliseconds
100.00% <= 2 milliseconds
126742.72 requests per second

====== SADD ======
  100000 requests completed in 0.79 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.90% <= 1 milliseconds
99.95% <= 2 milliseconds
100.00% <= 2 milliseconds
127388.53 requests per second

====== SPOP ======
  100000 requests completed in 0.79 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.90% <= 2 milliseconds
100.00% <= 2 milliseconds
126903.55 requests per second

====== LPUSH (needed to benchmark LRANGE) ======
  100000 requests completed in 0.79 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.87% <= 1 milliseconds
99.91% <= 2 milliseconds
99.92% <= 3 milliseconds
100.00% <= 3 milliseconds
126262.62 requests per second

====== LRANGE_100 (first 100 elements) ======
  100000 requests completed in 2.01 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.70% <= 1 milliseconds
99.80% <= 2 milliseconds
99.95% <= 3 milliseconds
100.00% <= 3 milliseconds
49800.80 requests per second

====== LRANGE_300 (first 300 elements) ======
  100000 requests completed in 5.39 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

1.82% <= 1 milliseconds
98.70% <= 2 milliseconds
99.43% <= 3 milliseconds
99.75% <= 4 milliseconds
99.96% <= 5 milliseconds
100.00% <= 5 milliseconds
18556.32 requests per second

====== LRANGE_500 (first 450 elements) ======
  100000 requests completed in 7.63 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

0.23% <= 1 milliseconds
59.65% <= 2 milliseconds
98.03% <= 3 milliseconds
99.05% <= 4 milliseconds
99.73% <= 5 milliseconds
99.94% <= 6 milliseconds
99.98% <= 7 milliseconds
100.00% <= 8 milliseconds
100.00% <= 8 milliseconds
13107.88 requests per second

====== LRANGE_600 (first 600 elements) ======
  100000 requests completed in 9.94 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

0.12% <= 1 milliseconds
19.07% <= 2 milliseconds
85.39% <= 3 milliseconds
98.07% <= 4 milliseconds
99.00% <= 5 milliseconds
99.49% <= 6 milliseconds
99.76% <= 7 milliseconds
99.91% <= 8 milliseconds
99.97% <= 9 milliseconds
99.99% <= 10 milliseconds
100.00% <= 10 milliseconds
10059.35 requests per second

====== MSET (10 keys) ======
  100000 requests completed in 1.02 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.78% <= 1 milliseconds
99.90% <= 2 milliseconds
100.00% <= 2 milliseconds
97847.36 requests per second

3.测试实例：redis-benchmark -n 1000000 -c 100

这里-n从

-n <requests>      Total number of requests (default 100000)

可以看出，代表是请求，总计的请求数量，默认是100000，这里改为了1000000；

-c从

 -c <clients>       Number of parallel connections (default 50)

可以看出代表并行链接的客户端数量，默认是50，这里改为了100.

hadoop@Master:~/cloud/redis-3.0.4$ redis-benchmark -n 1000000 -c 100
====== PING_INLINE ======
  1000000 requests completed in 8.18 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.74% <= 1 milliseconds
99.86% <= 2 milliseconds
99.97% <= 3 milliseconds
100.00% <= 4 milliseconds
100.00% <= 4 milliseconds
122279.28 requests per second

====== PING_BULK ======
  1000000 requests completed in 8.33 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.64% <= 1 milliseconds
99.76% <= 2 milliseconds
99.93% <= 3 milliseconds
99.99% <= 4 milliseconds
100.00% <= 4 milliseconds
120062.42 requests per second

====== SET ======
  1000000 requests completed in 8.20 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.66% <= 1 milliseconds
99.79% <= 2 milliseconds
99.93% <= 3 milliseconds
100.00% <= 4 milliseconds
100.00% <= 4 milliseconds
122010.73 requests per second

====== GET ======
  1000000 requests completed in 8.18 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.74% <= 1 milliseconds
99.83% <= 2 milliseconds
99.96% <= 3 milliseconds
100.00% <= 3 milliseconds
122234.45 requests per second

====== INCR ======
  1000000 requests completed in 8.13 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.71% <= 1 milliseconds
99.84% <= 2 milliseconds
99.94% <= 3 milliseconds
100.00% <= 3 milliseconds
123061.77 requests per second

====== LPUSH ======
  1000000 requests completed in 8.09 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.67% <= 1 milliseconds
99.83% <= 2 milliseconds
99.96% <= 3 milliseconds
100.00% <= 4 milliseconds
100.00% <= 4 milliseconds
123609.39 requests per second

====== LPOP ======
  1000000 requests completed in 8.14 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.54% <= 1 milliseconds
99.79% <= 2 milliseconds
99.93% <= 3 milliseconds
99.97% <= 4 milliseconds
99.98% <= 5 milliseconds
99.99% <= 6 milliseconds
99.99% <= 7 milliseconds
100.00% <= 7 milliseconds
122865.22 requests per second

====== SADD ======
  1000000 requests completed in 8.04 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.72% <= 1 milliseconds
99.86% <= 2 milliseconds
99.97% <= 3 milliseconds
100.00% <= 3 milliseconds
124393.59 requests per second

====== SPOP ======
  1000000 requests completed in 8.09 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.69% <= 1 milliseconds
99.85% <= 2 milliseconds
99.99% <= 3 milliseconds
100.00% <= 4 milliseconds
100.00% <= 4 milliseconds
123624.68 requests per second

====== LPUSH (needed to benchmark LRANGE) ======
  1000000 requests completed in 8.13 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

99.47% <= 1 milliseconds
99.81% <= 2 milliseconds
99.94% <= 3 milliseconds
99.98% <= 4 milliseconds
99.99% <= 5 milliseconds
100.00% <= 5 milliseconds
123031.49 requests per second

====== LRANGE_100 (first 100 elements) ======
  1000000 requests completed in 20.18 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

42.68% <= 1 milliseconds
99.34% <= 2 milliseconds
99.80% <= 3 milliseconds
99.95% <= 4 milliseconds
100.00% <= 4 milliseconds
49546.65 requests per second

====== LRANGE_300 (first 300 elements) ======
  1000000 requests completed in 54.01 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

0.01% <= 1 milliseconds
2.15% <= 2 milliseconds
75.25% <= 3 milliseconds
98.11% <= 4 milliseconds
99.04% <= 5 milliseconds
99.50% <= 6 milliseconds
99.76% <= 7 milliseconds
99.89% <= 8 milliseconds
99.95% <= 9 milliseconds
99.98% <= 10 milliseconds
100.00% <= 11 milliseconds
100.00% <= 12 milliseconds
100.00% <= 13 milliseconds
100.00% <= 13 milliseconds
18513.72 requests per second

====== LRANGE_500 (first 450 elements) ======
  1000000 requests completed in 75.73 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

0.00% <= 1 milliseconds
0.03% <= 2 milliseconds
11.64% <= 3 milliseconds
59.78% <= 4 milliseconds
98.00% <= 5 milliseconds
99.22% <= 6 milliseconds
99.60% <= 7 milliseconds
99.78% <= 8 milliseconds
99.87% <= 9 milliseconds
99.93% <= 10 milliseconds
99.97% <= 11 milliseconds
99.98% <= 12 milliseconds
99.99% <= 13 milliseconds
100.00% <= 14 milliseconds
100.00% <= 15 milliseconds
100.00% <= 15 milliseconds
13205.16 requests per second

====== LRANGE_600 (first 600 elements) ======
  1000000 requests completed in 98.43 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

0.00% <= 1 milliseconds
0.01% <= 2 milliseconds
0.17% <= 3 milliseconds
15.85% <= 4 milliseconds
53.14% <= 5 milliseconds
89.14% <= 6 milliseconds
99.06% <= 7 milliseconds
99.53% <= 8 milliseconds
99.75% <= 9 milliseconds
99.85% <= 10 milliseconds
99.91% <= 11 milliseconds
99.94% <= 12 milliseconds
99.96% <= 13 milliseconds
99.98% <= 14 milliseconds
99.99% <= 15 milliseconds
99.99% <= 16 milliseconds
100.00% <= 17 milliseconds
100.00% <= 17 milliseconds
10159.92 requests per second

====== MSET (10 keys) ======
  1000000 requests completed in 10.11 seconds
  100 parallel clients
  3 bytes payload
  keep alive: 1

83.03% <= 1 milliseconds
99.25% <= 2 milliseconds
99.88% <= 3 milliseconds
99.96% <= 4 milliseconds
99.98% <= 5 milliseconds
99.99% <= 6 milliseconds
100.00% <= 6 milliseconds
98872.84 requests per second

4.测试实例： redis-benchmark -t set -n 1000000 -r 100000000

Fill 127.0.0.1:6379 with about 1 million keys only using the SET test: 仅仅使用set测试，一百万请求

hadoop@Master:~/cloud/redis-3.0.4$ redis-benchmark -t set -n 1000000 -r 100000000
====== SET ======
  1000000 requests completed in 8.29 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

99.42% <= 1 milliseconds
99.85% <= 2 milliseconds
99.96% <= 3 milliseconds
99.99% <= 4 milliseconds
100.00% <= 5 milliseconds
100.00% <= 5 milliseconds
120685.49 requests per second

5.测试实例： redis-benchmark -t ping,set,get -n 100000 --csv

测试ping，set,get，请求书为100000，输出格式为CSV

hadoop@Master:~/cloud/redis-3.0.4$  redis-benchmark -t ping,set,get -n 100000 --csv
"PING_INLINE","123304.56"
"PING_BULK","123609.39"
"SET","81967.21"
"GET","125470.52"

6.执行一个特别的指令：redis-benchmark -r 10000 -n 10000 eval 'return redis.call("ping")' 0

随机值在10000以内，请求数为10000，

hadoop@Master:~/cloud/redis-3.0.4$ redis-benchmark -r 10000 -n 10000 eval 'return redis.call("ping")' 0
====== eval return redis.call("ping") 0 ======
  10000 requests completed in 0.12 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

98.90% <= 1 milliseconds
100.00% <= 1 milliseconds
80000.00 requests per second

7.测试实例：redis-benchmark -r 10000 -n 10000 lpush mylist __rand_int__

用10000个随机元素填充一个list，列表。随机数的值为10000以内

hadoop@Master:~/cloud/redis-3.0.4$ redis-benchmark -r 10000 -n 10000 lpush mylist __rand_int__
====== lpush mylist __rand_int__ ======
  10000 requests completed in 0.18 seconds
  50 parallel clients
  3 bytes payload
  keep alive: 1

49.79% <= 1 milliseconds
98.90% <= 2 milliseconds
99.22% <= 4 milliseconds
99.48% <= 6 milliseconds
99.51% <= 8 milliseconds
99.54% <= 14 milliseconds
100.00% <= 14 milliseconds
55865.92 requests per second

8.测试实例：redis-benchmark  -q -d 100  

测试存取大小为100字节的数据包的性能 

hadoop@Master:~/cloud/redis-3.0.4$ redis-benchmark  -q -d 100  
PING_INLINE: 124533.01 requests per second
PING_BULK: 124378.11 requests per second
SET: 80775.45 requests per second
GET: 123001.23 requests per second
INCR: 126582.27 requests per second
LPUSH: 125786.16 requests per second
LPOP: 125000.00 requests per second
SADD: 126262.62 requests per second
SPOP: 127713.92 requests per second
LPUSH (needed to benchmark LRANGE): 126582.27 requests per second
LRANGE_100 (first 100 elements): 40241.45 requests per second
LRANGE_300 (first 300 elements): 15167.60 requests per second
LRANGE_500 (first 450 elements): 10256.41 requests per second
LRANGE_600 (first 600 elements): 7227.00 requests per second
MSET (10 keys): 92850.51 requests per second


KeepLearningBigData
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis-benchmark使用
zxk082829的博客
05-10 332
Invalid option "-help" or option argument missing Usage: redis-benchmark [-h <host>] [-p <port>] [-c <clients>] [-n <requests>] [-k <boolean>] -h <hostname> ...
redis 学习3 ---redis-benchmark使用
qq_42572322的博客
08-30 162
redis-benchmark可以用来测试性能 50个并发10000个请求，压测命令：redis-benchmark -h 127.0.0.1 -p 6379 -c 50 -n 10000 压测需要一段时间，因为它需要依次压测多个命令的结果，如：get、set、incr、lpush等等，所以我们需要耐心等待，如果只需要压测某个命令，如：get，那么可以在以上的命令后加一个参数-t（红色部分）： 1、redis-benchmark -h 127.0.0.1 -p 6086 -c 50 -..
【redis】redis-benchmark 详解
最新发布
weixin_43346403的博客
06-19 490
【代码】【redis】redis-benchmark 详解。
redis-benchmark 官方性能测试软件使用总结
qq_42099097的博客
12-14 237
1. 使用redis-benchmark前要了解的基本命令语句 2.进行测试的步骤 第一步：开启redis-server 第二步:进入redis软件存放的cmd 第三步;输入命令：redis-benchmark -hlocalhost -p 6379 -n 1000 -c 50 3.总结： redis-benchmark主要是用来进行压力测试的软件，我们需要掌握的是如何通过该工具来测试出在特定情况下的效果。 通过该工具，我们也了解到了redis的处理速度之...
Redis：性能测试 redis-benchmark
李白
03-18 540
Redis 性能测试是通过同时执行多个命令实现的。 语法 redis 性能测试的基本命令如下： redis-benchmark [option] [option value] 注意：该命令是在 redis 的目录下执行的，而不是 redis 客户端的内部指令。 redis 性能测试工具可选参数如下所示： 序号 选项 描述 默认值 1 -h 指定服务器主机名 127.0.0.1 2 -p 指定服务器端口 6379 3 -s
redis学习：redis-benchmark性能测试工具
m0_67390969的博客
04-07 511
redis-benchmark 官方提供的测试工具 他的参数如下: 进行性能测试（前提是在redis服务端和客户端都要启动的情况下，可以查看redis进程） 进入到redis的安装目录 # 测试：100个并发连接 100000请求 redis-benchmark -h localhost -p 6379 -c 100 -n 100000 set命令的百分比分布的延迟 set命令延迟累积分布 可以看到我这台服务器上的redis100000个请求不到3毫秒就完成了，这性能确实快。 ...
redis-7.2-x64-for-windows-bin.zip
09-04
10. **redis-benchmark.exe**: 这是Redis的性能测试工具，可以用来衡量Redis服务器的吞吐量和响应时间，帮助优化配置和硬件选择。 11. **data**: 这个目录可能包含Redis默认的数据存储位置，用户可以将Redis的数据...
redis-6.2.4-x64-windows-bin.zip
06-15
在 Redis 6.0 或更新的版本中，有一个整数溢出漏洞，可通过使用 STRALGO LCS 命令来破坏堆，可能导致远程代码 执行。这是由 CVE-2021-29477 的不完整修复造成的。 只适用于 Redis 6.2 以前版本的错误修复： 修复 ...
redis-benchmark.exe
12-11
redis-benchmark.exe--
redis-windows-7.0.10.zip
04-14
Redis的核心组件包括`redis-server.exe`（服务器进程）、`redis-cli.exe`（命令行客户端）以及`redis-benchmark.exe`（性能测试工具）等。用户需要通过`redis-server.exe`启动服务，并通过`redis-cli.exe`进行交互式...
redis-windows-7.2.2.zip
10-26
2. **redis-cli.exe**：Redis客户端工具，提供交互式的命令行界面，允许用户发送命令到Redis服务器，查看和操作数据，进行配置修改等操作。 3. **redis.conf**：Redis的配置文件，包含了服务器的各种设置，如端口号...
Redis稳定版 Redis-x64-5.0.14.1.zip
07-21
- `redis-benchmark`: 性能测试工具，用于测量Redis的读写速度。 - `redis-check-aof`: 检查AOF日志文件的工具，确保其一致性。 - `redis-check-rdb`: 检查RDB快照文件的工具，确认数据无损。 安装Redis-x64-5.0....
redis-7.0.12-x64-windows.rar
07-17
- `redis-benchmark.exe`: Redis性能测试工具，用于测量Redis实例的吞吐量和延迟。 在安装和使用Redis时，你需要： 1. 解压压缩包到一个目录。 2. 根据需要修改`redis-7.0.conf`配置文件。 3. 启动`redis-server....
redis-7.0.11-windows.zip
04-23
2. **redis.conf**：这是 Redis 的默认配置文件，其中包含了各种服务器参数，如端口号、数据文件路径、持久化策略等。用户可以根据需求修改此文件以定制 Redis 服务器的行为。 3. **redis-server.exe**：这是 Redis...
Redis及其管理工具：Redis-x64-5.0.14.1、RESP-app
11-03
2. `redis.windows-service.conf`和`redis.windows.conf`是Redis在Windows环境下的配置文件。`windows-service.conf`可能用于将Redis作为Windows服务运行，而`windows.conf`则是通用的配置文件，可以自定义Redis...
Redis-x64-5.0.14.1
03-01
- 使用`redis-check-aof.exe`和`redis-check-rdb.exe`定期检查数据文件的完整性，确保数据安全。 5. **注意事项**： - Windows版本的Redis可能不如Linux稳定，因此生产环境中通常建议在Linux上部署Redis。 - ...
redis-benchmark-Redis性能测试工具(自带)
typ2004的专栏
08-23 6837
$ redis-benchmark --help Usage: redis-benchmark [-h ] [-p ] [-c ] [-n [-k ]  -h       Server hostname (default 127.0.0.1)  -p           Server port (default 6379)  -s         Server socket (ove
Redis源码分析（十三）--- redis-benchmark性能测试
走在前往架构师的路上
10-18 5775
今天讲的这个是用来给redis数据库做性能测试的，说到性能测试，感觉这必然是高大上的操作了，redis性能测试，测的到底是哪方面的性能，如何测试，通过什么指标反映此次测试的性能好坏呢，下面我通过源码给大家做一一解答。      redis做的性能测试时对立面的基本操作做的检测，比如Client客户端执行set，get，lpush等数据操作的性能，可以从他的测试程序可以看出： if (test
benchmark问题_一文看懂redis性能测试工具--Redis-benchmark
weixin_32306885的博客
01-18 138
概述很多人可能只是安装部署redis，并没有深入学习，但其实redis还可以用来做性能测试，Redis 性能测试是通过同时执行多个命令实现的。下面一起来看下吧~01语法redis 性能测试的基本命令如下：redis-benchmark [option] [option value]redis 性能测试工具可选参数如下所示：02实例1、redis-benchmark -h 127.0.0.1 -p ...
try.redis能否完成redis-benchmark压力测试
11-21
2. 如果需要对Redis服务器进行认证，则可以使用以下命令： ```shell redis-benchmark -a password ``` 其中，password是Redis服务器的密码。 3. 如果需要测试指定数量的客户端，则可以使用以下命令： ```...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值