redisredisnoSQL

Redis服务器搭建

2017-06-07  本文已影响1081人  64d1c00cca37

Redis简介

Redis全称：Remote Dictionary Server(远程数据服务)。Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis安装配置（Linux平台）

Redis编译与安装

在进行redis的编译安装需要先进行 apt-get install make

1.将Redis开发包上传到Linux系统之中，但是需要注意，由于给出的开发包属于源代码，所以建议解压缩到/usr/local/src目录之中；

tar -xzvf /srv/ftp/redis-3.2.9.tar.gz -C /usr/local/src/

2.进入到redis源代码所在的安装目录：cd /usr/local/src/redis-3.2.9/
3.进行程序的编译处理，输入：make
4.编译完成之后要进行Redis安装，输入：make install
5.Redis属于内存缓存数据库，那么如果你现在是一台单独的Redis服务器，则应该考虑将所有的可用内存都交给Redis来进行支配，所以理论上还需要执行如下的一行代码：

echo "vm.overcommit_memory=1" >> /etc/sysctl.conf

本次的操作指的是进行一次内存的分配策略，在进行设置的时候vm.overcommit_memory属性有如下三个取值：

6.将以上的配置写入到内核参数之中：/sbin/sysctl -p
7.为了方便使用Redis数据库，那么建立一个Redis支持的命令工具目录：

mkdir -p /usr/local/redis/{bin,conf}

8.通过源代码目录拷贝出Redis所需要的程序运行文件：

9.拷贝出一个配置文件：

cp /usr/local/src/redis-3.2.9/redis.conf /usr/local/redis/conf/

Redis数据库配置

如果要想配置Redis数据库，主要的配置文件就是redis.conf，所有的配置项一定要在此处完成。

  1. Redis作为一个具备有持久化功能的缓存数据库，所以其一定会有一个用于数据存储的目录，那么一般在 Redis 处理的时候会有三类文件需要做保存：Redis运行时的pid、Redis相关处理日志、Redis的数据文件，所以建立一个目录用于存放这些数据：
mkdir -p /usr/data/redis/{run,logs,dbcache}

2.修改redis.conf的配置文件：vim /usr/local/redis/conf/redis.conf

3.启动Redis服务：/usr/local/redis/bin/redis-server /usr/local/redis/conf/redis.conf

4.Redis启动会占用6379的端口，所以查看端口：netstat -nptl；

5.启动Redis客户端：
方式一：连接本机6739端口的Redis : /usr/local/redis/bin/redis-cli
方式二：连接远程的格式 : /usr/local/redis/bin/redis-cli -h 127.0.0.1 -p 6379

6.设置一个数据：set myredis java；
7.取得数据：get myredis
8.关闭Redis服务：

9、redis日志查看目录：/usr/data/redis/logs

cat redis.log

Redis数据操作

Redis支持各种的数据类型，而且Redis操作的速度很快的，在Redis数据库里面有一个redis-benchmark性能测试工具，可以直接使用这个工具来观察Redis使用，该命令所需要的参数如下：

root@redis-single:~# /usr/local/redis/bin/redis-benchmark --help
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)
 -a <password>      Password for Redis Auth
 -c <clients>       Number of parallel connections (default 50)
 -n <requests>      Total number of requests (default 100000)
 -d <size>          Data size of SET/GET value in bytes (default 2)
 -dbnum <db>        SELECT the specified db number (default 0)
 -k <boolean>       1=keep alive 0=reconnect (default 1)
 -r <keyspacelen>   Use random keys for SET/GET/INCR, random values for 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).
 -e                 If server replies with errors, show them on stdout.
                    (no more than 1 error per second is displayed)
 -q                 Quiet. Just show query/sec values
 --csv              Output in CSV format
 -l                 Loop. Run the tests forever
 -t <tests>         Only run the comma separated list of tests. The test
                    names are the same as the ones produced as output.
 -I                 Idle mode. Just open N idle connections and wait.

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.

范例：下面模拟1000个客户端进行数据的处理

/usr/local/redis/bin/redis-benchmark -h 127.0.0.1 -p 6379 -c 1000 -d 10 -n 10000

此时的命令之中的具体参数含义如下：

  • -h：要连接的Redis服务器的地址；

随后来观察一下当前的测试结果，会包含有如下的信息内容：

  • PING_INLINE： 44247.79 requests per second；

字符串类型

在Redis里面有一个特别重要的命令keys，可以进行全部数据的列出。其中后面的*****表示数据的匹配。

1、设置新的数据：set KEY VALUE

set username tom

2、取得对应的数据：get KEY

get username

3.清空仓库：flushdb；
4.不覆盖设置内容：setnx KEY VALUE

setnx username JAMES
setnx username JAMES

set uname james
set uname tom

5.设置数据保存的有效时间：setnx KEY VALUE

setex wechat_code 60 3452

6.设置多个key的内容：mset KYE1 VALUE1 KEY2 VALUE2...

mset username-110 hello username-120 world username-119 cry

那么此时同时设置有三个key的信息，如果此时设置有相同的key的信息，那么默认会出现覆盖的问题：

mset username-110 hello1 username-120 world1 username-119 cry1

7.不覆盖设置多个key：msetnx KEY1 VALUE1 KEY2 VALUE2...

msetnx username-110 hello2 username-1 hello username-2 world

msetnx username-1 hello username-2 world

8.内容追加：a1end KEY CONTENT

a1end username-110 world

返回的是当前的内容的长度；
9.取得指定key的内容长度：strlen KEY

strlen username-110

10.删除指定的数据内容：del KEY1 KEY2 ...

del 110-code username-1 username-99

如果现在指定的key不存在，也不会影响到程序的执行，只会删除掉存在的key的信息。
以下为redis执行代码：

127.0.0.1:6379> set username tom
OK
127.0.0.1:6379> get username
"tom"
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> setnx username JAMES
(integer) 1
127.0.0.1:6379> setnx username JAMES
(integer) 0
127.0.0.1:6379> get username
"best"
127.0.0.1:6379> set uname james
OK
127.0.0.1:6379> set uname tom
OK
127.0.0.1:6379> get uname
"tom"
127.0.0.1:6379> setex wechat_code 60 3452 
OK
127.0.0.1:6379> get wechat_code
"3452"
127.0.0.1:6379> get wechat_code
(nil)
127.0.0.1:6379> mset username-110 hello username-120 world username-119 cry
OK
127.0.0.1:6379> mset username-110 hello1 username-120 world1 username-119 cry1
OK
127.0.0.1:6379> get username-110
"hello1"
127.0.0.1:6379> msetnx username-110 hello2 username-1 hello username-2 world
(integer) 0
127.0.0.1:6379> msetnx username-1 hello username-2 world
(integer) 1
127.0.0.1:6379> a1end username-110 world
(integer) 11
127.0.0.1:6379> del 110-code username-1 username-99
(integer) 1

Hash数据类型

Hash是一种最为常见的数据类型，其保存的数据结构为key = value，但是需要提醒的是这个时候的key与value并不是redis中的key和value，hash是作为一种类型，可以这样理解关系：RedisKey = HashValue，利用Hash类型可以保存更多的数据。
1.存放Hash数据：hset hash-key sub-key1 value1
设置一个Hash类型，保存一个用户的用户名和真实姓名：
结构：mid为用户名的保存的属性名称、7396为真实的用户名；

hset member mid 7396
hset member name tom

2.取得散列包含的所有键值内容：hgetall hash-key
它在进行数据排列的时候采用的模式为：hash-key、hash-value、hash-key、hash-value。

hgetall member

取得指定key的内容：

3.默认情况下hset会进行覆盖设置，那么使用hsetnx就可以避免掉这种覆盖设置的问题：

4.数据批量设置：hmset member-1 name wusheng age 55 province hb；
5.判断某个key的某个属性是否存在：hexists member-1 school；
6.取得全部的数据的成员个数：hlen member；
7.删除指定的key的内容：hdel member-1 age,name；
8.取得一个hash中的所有的key（成员）内容：hkeys member-1；
9.取得指定hash中的所有内容：hvals member；

以下为具体代码操作：

127.0.0.1:6379> hset member mid 7396
(integer) 1
127.0.0.1:6379> hset member name tom
(integer) 1
127.0.0.1:6379> hgetall member
1) "mid"
2) "7396"
3) "name"
4) "tom"
127.0.0.1:6379> hget member mid
"7396"
127.0.0.1:6379> hsetnx member mid hello
(integer) 0
127.0.0.1:6379> hsetnx member-aa mid hello
(integer) 1
127.0.0.1:6379> keys *
1) "username-120"
2) "username-110"
3) "member"
4) "username-2"
5) "username"
6) "member-aa"
7) "uname"
8) "username-119"
127.0.0.1:6379> hmset member-1 name wusheng age 15 province beijing
OK
127.0.0.1:6379> hexists member-1 school
(integer) 0
127.0.0.1:6379> hlen member
(integer) 2
127.0.0.1:6379> hdel member-1 age,name
(integer) 0
127.0.0.1:6379> hkeys member-1
1) "name"
2) "age"
3) "province"
127.0.0.1:6379> hvals member
1) "7396"
2) "tom"

数字操作

普通数据类型

1.如果要进行数字的操作，那么肯定要设置两个数字的内容：

2.进行普通数据类型的数字操作：

3.进行Hash数据类型的数字操作：hincrby sc pid-72378 1实际上整个数字操作里面只需要记住两个命令：incrby、hincrby就够了。

127.0.0.1:6379> set shopcar-pid 100
OK
127.0.0.1:6379> hset sc pid-72378 100
(integer) 1
127.0.0.1:6379> incr shopcar-pid
(integer) 101
127.0.0.1:6379> incrby shopcar-pid 200
(integer) 301
127.0.0.1:6379> incrby shopcar-pid 5
(integer) 306
127.0.0.1:6379> decr shopcar-pid
(integer) 305
127.0.0.1:6379> decrby shopcar-pid 100
(integer) 205
127.0.0.1:6379> hincrby sc pid-72378 1
(integer) 101

List数据类型

List数据类型是一种比较麻烦的处理操作。在实际的项目开发里面，List就是一个链表结构，那么链表结构的时间复杂度是n，而且在进行链表数据处理的时候主要是进行内容的保存、节点的设置、递归遍历。

1.左边压入创建一个描述关键字的List集合：lpush javaee redis java hello happy word cloud；
push属于入栈，栈的特点是先进后出；
2.进行指定范围的链表数据输出：lrange javaee 0 -1，如果设置为-1则表示输出全部的内容。
3.右边压入进行入栈处理：rpush javaee 1 2 3 4 5 6 7；
4.在指定元素（hello）上追加内容：
在指定元素前追加：linsert javaee before hello hello-before；

5.删除数据：lrem javaee 5 hello；
6.保留指定范围的数据：ltrim javaee 0 9，范围编号不在0 ~ 9之间的所有数据将被删除掉；
7.栈顶元素出栈：lpop javaee；
8.栈底元素出栈：rpop javaee。
9.将移除的数据保存到另一个集合：rpoplpush javaee new_javaee
表示将javaee的集合中的栈底的一个元素出栈，而后压入到new_javaee这个集合的栈顶。
10.取得指定索引对应的数据：lindex javaee 0；
11.取得集合个数：llen javaee；

127.0.0.1:6379> lpush javaee redis java hello happy word cloud
(integer) 6
127.0.0.1:6379> lrange javaee 0 -1
1) "cloud"
2) "word"
3) "happy"
4) "hello"
5) "java"
6) "redis"
127.0.0.1:6379> rpush javaee 1 2 3 4 5 6 7
(integer) 13
127.0.0.1:6379> linsert javaee before hello hello-before
(integer) 14
127.0.0.1:6379> linsert javaee after hello hello-after
(integer) 15
127.0.0.1:6379> lrange javaee 0 -1
 1) "cloud"
 2) "word"
 3) "happy"
 4) "hello-before"
 5) "hello"
 6) "hello-after"
 7) "java"
 8) "redis"
 9) "1"
10) "2"
11) "3"
12) "4"
13) "5"
14) "6"
15) "7"
127.0.0.1:6379> lrem javaee 5 hello
(integer) 1
127.0.0.1:6379> ltrim javaee 0 9
OK
127.0.0.1:6379> lrange javaee 0 -1
 1) "cloud"
 2) "word"
 3) "happy"
 4) "hello-before"
 5) "hello-after"
 6) "java"
 7) "redis"
 8) "1"
 9) "2"
10) "3"
127.0.0.1:6379> lpop javaee
"cloud"
127.0.0.1:6379> rpop javaee
"3"
127.0.0.1:6379> rpoplpush javaee new_javaee 
"2"
127.0.0.1:6379> lrange new_javaee 0 -1
1) "2"
127.0.0.1:6379> lindex javaee 0
"word"
127.0.0.1:6379> llen javaee
(integer) 7

Set数据类型

Set也是一种常见的数据类型，其最大的特征是基于数据的集合比对处理，例如：可以实现数据的交集、并集、差集。
1.向集合之中追加新元素：sadd user-redis a b c d e；
此时向该集合之中追加有五个元素，可以把每一个元素想象为一个用户名；
2.查询set集合处理：smembers user-redis，List集合是有序的，而Set集合是无序的。
3.删除set集合元素：srem user-redis a；
4.从集合中弹出元素（该元素会自动进行删除处理）：spop user-redis；
5.返回两个集合的差集合：
准备出第一个集合：sadd user-redis a b c d e
准备出第二个集合：sadd user-admin a c e x y z
进行差运算：sdiff user-redis user-admin
6.保存差集的运行结果到其它集合：sdiffstore user-admin-redis user-admin user-redis
将user-admin与user-redis两个用户的数据进行差集的计算处理，并且将结果保存到user-admin-redis集合中；
查看差集的保存：smembers user-admin-redis
7.交集运算：sinter user-redis user-admin；
将交集保存到指定的集合里面去：sinterstore user-admin-redis-inter user-admin user-redis；
8.并集运算：sunion user-admin user-redis；
将并集保存到指定的集合里面：sunionstore user-admin-redis-union user-admin user-redis；
9.弹出数据到另外的集合中：smove user-redis user-redis-tmp a；
10.返回集合个数：scard user-redis；
11.判断指定的集合中是否包含有指定的元素存在：sismember user-redis b，如果存在返回 1，不存在返回 0；
12.虽然返回集合中的数据：srandmember user-redis 3；
其中后面可以设置返回的数据个数，如果不设置默认为 1；

SortedSet集合

Set集合的最大特征是可以进行数据比对，但是Set数据本身是属于无序的保存，所以如果需要进行数据的顺序保存，那么可以采用SortedSet，这个也不算是一个顺序保存，更多的情况下该集合可以保存有一个分数，而这个分数的操作就可以作为一些数据的统计结果出现。

1.增加SortedSet数据：

zadd user-redis 1 pid-1 
zadd user-redis 1 pid-2 
zadd user-redis 1 pid-3

现在假设这些商品的信息该用户只看了一次，所以每一个数据的分数为1。
2.取得sortedSet集合中的全部数据：
显示所有的数据的元素：zrange user-redis 0 -1；
显示每一个元素和其对应的分数：zrange user-redis 0 -1 withscores；
也可以输出指定范围的数据：zrange user-redis 0 2 withscores；
3.从集合里面删除数据：zrem user-redis pid-；
4.元素分数的增长：zincrby user-redis 5 pid-1，会返回有当前增长后的数据内容；
5.取得指定元素的索引内容：zrank user-redis pid-1，索引值从0开始；
6.数据反转处理取得索引：zrevrank user-redis pid-1；
7.反转后取得数据：zrevrange user-redis 0 -1 withscores；
8.根据分数范围取得数据：
闭区间处理：zrangebyscore user-redis 3 6 withscores，包含了3和6
开区间处理：zrangebyscore user-redis (3 (6 withscores；
设置一个范围：zrangebyscore user-redis 1 10 withscores limit 0 2；
9.取得指定分数范围的数据量：zcount user-redis 2 8；
10.取得指定key中的集合数量：zcard user-redis；
取得指定的分析的key：keys *；
11.根据索引下标删除数据：zremrangebyrank user-redis 0 5；
总结

1.基本类型（String、int）：基本类型的操作更加适合于用户进行短期的数据存储，因为在实际的开发之中，字符串可以进行各种复杂操作，而且字符串也可以描述出各种数据的含义。那么在实际的开发之中，可以利用此类型使用Nginx的集群数据保存、Shiro的集群数据保存、SpringData数据保存（序列化）、JSON数据的保存；
2.hash类型：hash类型更多的情况下描述的是一个结构化的信息，但是这种结构化的信息个人认为不如对象序列化好用，但是至少需要知道Hash这样的类型可以进行内容的详细分类；
3.List（栈、队列）：在实际的开发之中可以利用此类型实现消息队列的功能，或者进行缓冲的功能，很多公司有可能不直接使用消息队列中间件，而直接利用Redis代替。
4.Set数据类型：最大的支持功能在于集合的运算上，例如：相似度检测、好友推荐等等，都可以通过这种集合的处理方式来完成，应用案例：新浪微博。
5.SortedSet：主要进行数据的流式分析；
就以用户浏览商品操作为例。通过分数来进行商品推荐。

Redis事务处理

Redis本身支持事务处理，但是这种支持的事务处理本身是存在有设计缺陷的，而且与传统的关系型数据库的事务处理有些不同，首先先来看一下Redis中的事务支持命令：

设置一个数据：set age 30
打开事务支持：multi
QUEUED进行数据操作：set age 300
QUEUED进行数据操作：set age 3000
关闭事务：discard

一旦开启了Redis的事务控制，则表示所有的更新操作都要追加到一个更新队列之中。由于现在在执行完更新之后发现数据本身出现有问题了，所以选择了关闭事务，一旦事务关闭之后那么该操作将会回滚到最初的状态。

范例：执行事务提交

设置一个数据：set age 30
打开事务支持：multi
QUEUED进行数据操作：set age 50
提交事务：exec

如果在事务开启状态下进行了更新处理，随后只有执行了exec指令后才表示事务真正提交，才会真正影响到原始数据。 但是需要提醒的是，Redis设计之初就是不考虑事务的，所以以上的事务只能够说是Redis的一个玩笑，因为这种事务本身设计的并不完善。

设置一个数据：set id redis
打开事务支持：multi
QUEUED进行数据操作：incr id
QUEUED进行数据操作：set age 500
提交事务：exec

这个时候一旦提交事务一定会出现错误信息ERR value is not an integer or out of range，因为id的数据不是数字，所以无法进行数字的增长。而且一旦出现了错误之后，其它的更新操作依然可以正常完成。

Redis乐观锁

在数据库执行操作的时候，为了保证数据的一致性，即：A用户更新数据的时候B用户不能够更新。所谓的锁在数据库设计上分为两种：

SELECT * FROM member WHERE mid=1 FOR UPDATE ;

1.第一个Session执行如下的操作：

设置一个数据：set age 30
进行该数据的监听：watch age
启用事务：multi

这个时候并没有对age数据做任何的修改；

2.第二个session对数据进行修改操作：

覆盖age数据：set age 500
取得age数据：get age

3.第一个session对数据修改：

修改数据：set age 60
提交事务：exec

此时由于第二个Session已经更新了原始的数据，那么就表示该原始数据上的一个标记列更新，这样当第一个session再进行更新的时候会发现返回了(nil)，意味着本次更新失败。

Redis密码配置

如果说你现在的Redis没有进行认证的处理操作，那么所有的程序都可以进行连接。直接使用redis-cli命令只需要设置上主机名称和端口号就可以进行连接处理。那么为了安全必须要设置密码。 在Redis数据库设计的时候并没有像其它数据库那样准备了一堆复杂的密码或者权限的概念，在Redis里面只需要设置一个认证密码就可以解决问题。
1.修改redis.conf配置文件：vim /usr/local/redis/conf/redis.conf，追加以下内容:

requirepass redisjava

2.随后关闭掉redis服务并且重新启动：

3.登录redis服务器：/usr/local/redis/bin/redis-cli -h 127.0.0.1 -p 6379；

(error) NOAUTH Authentication required.

/usr/local/redis/bin/redis-cli -h 127.0.0.1 -p 6379 -a redisjava

所有的Redis服务一定要有认证密码，而且作为Redis集群设计的时候一定要将所有密码统一。

Redis性能监控

Redis是作为缓存数据库使用，那么一旦在开发之中使用了Redis，就表示有可能会大面积的去向Redis里面保存数据，那么现在如果要想知道当前的运行状态，那么就需要对其进行监控处理，如果要进行Redis监控，必须通过其它组件完成，本次使用一个redis-stat工具实现Redis监控操作，这个工具可以直接通过github找到。

mkdir -p /usr/data/redis/{redis-6379,redis-6380,redis-6381}/{run,logs,dbcache}

3.将之前的redis.conf配置文件拷贝一份：

cp /usr/local/redis/conf/redis.conf /usr/local/redis/conf//redis-6379.conf

4.编辑每一个配置文件，修改各自的内容，以redis-6379为例：vim /usr/local/redis/conf/redis-6379.conf

取消外网访问限制：# bind 127.0.0.1
设置端口：port 6379
设置pid保存路径：pidfile /usr/data/redis/redis-6379/run/redis_6379.pid
设置日志文件路径：logfile "/usr/data/redis/redis-6379/logs/redis.log"
数据文件目录：dir /usr/data/redis/redis-6379/dbcache

5.将redis-6379.conf复制为redis-6380.conf、redis-6381.conf

cp /usr/local/redis/conf/redis-6379.conf /usr/local/redis/conf//redis-6380.conf 
cp /usr/local/redis/conf/redis-6379.conf /usr/local/redis/conf//redis-6381.conf

随后进入到每一个配置文件进行6379内容的更新：1,$s/6379/6380/g，1,$s/6379/6381/g
6.启动所有的Redis服务：

/usr/local/redis/bin/redis-server /usr/local/redis/conf/redis-6379.conf 
/usr/local/redis/bin/redis-server /usr/local/redis/conf/redis-6380.conf 
/usr/local/redis/bin/redis-server /usr/local/redis/conf/redis-6381.conf

7.通过GITHUB下载redis-stat开发包：

8.下载下来的redis-stat里面实际上只有一个执行命令：/usr/local/redis-stat/bin/redis-stat；

9.启动 redis-stat 工具进行监听控制：

/usr/local/redis-stat/bin/redis-stat 192.168.125.136:6379 192.168.125.136:6380 192.168.125.136:6381 -a redisjava
redis-stat检测工具

10.该工具还支持WEB启动查看，也就是说它内部自动提供有一个HttpServer：

/usr/local/redis-stat/bin/redis-stat 192.168.125.136:6379 192.168.125.136:6380 192.168.125.136:6381 -a redisjava --server=80 --daemon --verbose

启动浏览器：http://192.168.125.136；

浏览器客户端

11.使用redis提供的工具来做测试：

/usr/local/redis/bin/redis-benchmark -h 192.168.125.136 -p 6379 -a redisjava -c 1000 -d 10 -n 10000
/usr/local/redis/bin/redis-benchmark -h 192.168.125.136 -p 6380 -a redisjava -c 1000 -d 10 -n 10000
/usr/local/redis/bin/redis-benchmark -h 192.168.125.136 -p 6381 -a redisjava -c 1000 -d 10 -n 10000
性能测试
上一篇下一篇

猜你喜欢

热点阅读