1、获取安装文件
wget http://download.redis.io/redis-stable.tar.gz
2、解压文件
tar xzvf redis-stable.tar.gz
3、进入目录
cd redis-stable
4、编译
make
5、安装
make install
6、设置配置文件路径
mkdir -p /etc/redis
cp redis.conf /etc/redis
7、修改配置文件
vi /etc/redis/redis.conf
仅修改： daemonize yes
8、启动
/usr/local/bin/redis-server /etc/redis/redis.conf
9、将Redis作为 Linux 服务随机启动
vim /etc/rc.local, 使用vi编辑器打开随机启动配置文件，并在其中加入下面一行代码。
/home/xxxx/redis-3.0/src/redis-server
9、查看启动
ps -ef | grep redis
10、使用客户端
redis-cli
>set name david
OK
>get name
"david"
11.停止Redis实例
最简单的方法是在启动实例的session中，直接使用Control-C来将实例停止。
我们还可以用客户端来停止服务，如可以用shutdown来停止Redis实例, 具体如下:
[root@localhost redis-3.0]# src/redis-cli shutdown
12.如何配置Redis
源码编译完成后，在redis-3.0目录下有一个redis.conf文件，这个文件即是Redis的配置文件
Redis支持很多的参数，但都有默认值。
●daemonize:
默认情况下，redis不是在后台运行的，如果需要在后台运行，把该项的值更改为yes。
●pidfile
当Redis在后台运行的时候，Redis默认会把pid文件放在/var/run/redis.pid，你可以配置到其他地址。当运行多个redis服务时，需要指定不同的pid文件和端口。
●bind
指定Redis只接收来自于该IP地址的请求，如果不进行设置，那么将处理所有请求，在生产环境中最好设置该项。
●port
监听端口，默认为6379。
●timeout
设置客户端连接时的超时时间，单位为秒。当客户端在这段时间内没有发出任何指令，那么关闭该连接。
●loglevel
log等级分为4级，debug, verbose, notice, 和warning。生产环境下一般开启notice。
●logfile
配置log文件地址，默认使用标准输出，即打印在命令行终端的窗口上。
●databases
设置数据库的个数，可以使用SELECT 命令来切换数据库。默认使用的数据库是0。
●save
设置Redis进行数据库镜像的频率。
if(在60秒之内有10000个keys发生变化时){
进行镜像备份
}else if(在300秒之内有10个keys发生了变化){
进行镜像备份
}else if(在900秒之内有1个keys发生了变化){
进行镜像备份
}
●rdbcompression
在进行镜像备份时，是否进行压缩。
●dbfilename
镜像备份文件的文件名。
●dir
数据库镜像备份的文件放置的路径。这里的路径跟文件名要分开配置是因为Redis在进行备份时，先会将当前数据库的状态写入到一个临时文件中，等备份完成时，再把该该临时文件替换为上面所指定的文件，而这里的临时文件和上面所配置的备份文件都会放在这个指定的路径当中。
●slaveof
设置该数据库为其他数据库的从数据库。
●masterauth
当主数据库连接需要密码验证时，在这里指定。
●requirepass
设置客户端连接后进行任何其他指定前需要使用的密码。警告：因为redis速度相当快，所以在一台比较好的服务器下，一个外部的用户可以在一秒钟进行150K次的密码尝试，这意味着你需要指定非常非常强大的密码来防止暴力破解。
●maxclients
限制同时连接的客户数量。当连接数超过这个值时，redis将不再接收其他连接请求，客户端尝试连接时将收到error信息。
●maxmemory
设置redis能够使用的最大内存。当内存满了的时候，如果还接收到set命令，redis将先尝试剔除设置过expire信息的key，而不管该key的过期时间还没有到达。在删除时，将按照过期时间进行删除，最早将要被过期的key将最先被删除。如果带有expire信息的key都删光了，那么将返回错误。这样，redis将不再接收写请求，只接收get请求。maxmemory的设置比较适合于把redis当作于类似memcached的缓存来使用。
●appendonly
默认情况下，redis会在后台异步的把数据库镜像备份到磁盘，但是该备份是非常耗时的，而且备份也不能很频繁，如果发生诸如拉闸限电、拔插头等状况，那么将造成比较大范围的数据丢失。所以redis提供了另外一种更加高效的数据库备份及灾难恢复方式。开启append only模式之后，redis会把所接收到的每一次写操作请求都追加到appendonly.aof文件中，当redis重新启动时，会从该文件恢复出之前的状态。但是这样会造成appendonly.aof文件过大，所以redis还支持了BGREWRITEAOF指令，对appendonly.aof进行重新整理。所以我认为推荐生产环境下的做法为关闭镜像，开启appendonly.aof，同时可以选择在访问较少的时间每天对appendonly.aof进行重写一次。
●appendfsync
设置对appendonly.aof文件进行同步的频率。always表示每次有写操作都进行同步，everysec表示对写操作进行累积，每秒同步一次。这个需要根据实际业务场景进行配置。
●vm-enabled
是否开启虚拟内存支持。因为redis是一个内存数据库，而且当内存满的时候，无法接收新的写请求，所以在redis 2.0中，提供了虚拟内存的支持。但是需要注意的是，redis中，所有的key都会放在内存中，在内存不够时，只会把value值放入交换区。这样保证了虽然使用虚拟内存，但性能基本不受影响，同时，你需要注意的是你要把vm-max-memory设置到足够来放下你的所有的key。
●vm-swap-file
设置虚拟内存的交换文件路径。
●vm-max-memory
这里设置开启虚拟内存之后，redis将使用的最大物理内存的大小。默认为0，redis将把他所有的能放到交换文件的都放到交换文件中，以尽量少的使用物理内存。在生产环境下，需要根据实际情况设置该值，最好不要使用默认的0。
●vm-page-size
设置虚拟内存的页大小，如果你的value值比较大，比如说你要在value中放置博客、新闻之类的所有文章内容，就设大一点，如果要放置的都是很小的内容，那就设小一点。
●vm-pages
设置交换文件的总的page数量，需要注意的是，page table信息会放在物理内存中，每8个page就会占据RAM中的1个byte。总的虚拟内存大小 = vm-page-size * vm-pages。
●vm-max-threads
设置VM IO同时使用的线程数量。因为在进行内存交换时，对数据有编码和解码的过程，所以尽管IO设备在硬件上本上不能支持很多的并发读写，但是还是如果你所保存的vlaue值比较大，将该值设大一些，还是能够提升性能的。
●glueoutputbuf
把小的输出缓存放在一起，以便能够在一个TCP packet中为客户端发送多个响应，具体原理和真实效果我不是很清楚。所以根据注释，你不是很确定的时候就设置成yes。
●hash-max-zipmap-entries
在redis 2.0中引入了hash数据结构。当hash中包含超过指定元素个数并且最大的元素没有超过临界时，hash将以一种特殊的编码方式(大大减少内存使用)来存储，这里可以设置这两个临界值。
●activerehashing
开启之后，redis将在每100毫秒时使用1毫秒的CPU时间来对redis的hash表进行重新hash，可以降低内存的使用。当你的使用场景中，有非常严格的实时性需要，不能够接受Redis时不时的对请求有2毫秒的延迟的话，把这项配置为no。如果没有这么严格的实时性要求，可以设置为yes，以便能够尽可能快的释放内存。
13.redis客户端（C语言）
上面介绍了redis 安装和简单使用操作，下面，我们来介绍一下redis client端的编写。
[root@localhost redis-3.0]# cd deps/hiredis/ [root@localhost hiredis]# make
[root@localhost hiredis]# make install
这种方式安装的安装库，没有到达默认目录，需要我们： [root@localhost hiredis] cp libhiredis.so /usr/lib64 /usr/lib （若是32系统只需要运行 cp libhiredis.so /usr/lib）
[root@localhost hiredis]# gcc test.c -o test -lhiredis
[root@loaclhost hiredis]# ./test
此时可能出现错误：
错误：expected identifier before numeric constant
错误：expected `}' before numeric constant
原因是：问题出在一个枚举enum类型上，发现与redis里面的枚举类型重复变量，改变一下枚举类型的变量即可。
[root@localhost hiredis]# gcc example.c -o example -lhiredis
[root@localhost hiredis]# ./example
此时可能出现错误：
error while loading shared libraries: libhiredis.so.0.10: cannot open shared object file: No such file or directory
原因是：是动态库的问题，是系统找不到这个动态库，此时记住sudo /sbin/ldconfig以下，更新一下系统动态库配置。
可能出现错误：
error: hiredis/hiredis.h: No such file or directory这是由于缺少hiredis依赖关系,解决方案：
On OSX run:
brew install hiredisand on Ubuntu:
apt-get install libhiredis-devon other platforms:
git clone https://github.com/antirez/hiredis.git && cd hiredis && make && sudo make install && sudo ldconfig编程时，可以参照example.c 的实例即可。
测试代码１：
1. #include <stdio.h>
2.
3. #include <hiredis/hiredis.h>
4.
5. int
6. {
7. "127.0.0.1",6379);
8. if(conn->err) printf("connection error:%s\n",conn->errstr);
9.
10. "set foo 1234");
11. freeReplyObject(reply);
12.
13. "get foo");
14.
15. "%s\n",reply->str);
16. freeReplyObject(reply);
17.
18. redisFree(conn);
19.
20. return
21.
22. }在下面的代码示例中，将给出两种最为常用的Redis命令操作方式，既普通调用方式和基于管线的调用方式。
1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <stddef.h>
4. #include <stdarg.h>
5. #include <string.h>
6. #include <assert.h>
7. #include <hiredis/hiredis.h>
8.
9. void
10. {
11. int
12. struct
13. tv.tv_sec = timeout / 1000;
14. tv.tv_usec = timeout * 1000;
15. //以带有超时的方式链接Redis服务器，同时获取与Redis连接的上下文对象。
16. //该对象将用于其后所有与Redis操作的函数。
17. char*)"127.0.0.1", 6379);
18. if
19. redisFree(c);
20. return;
21. }
22. const char* command1 = "set stest1 value9";
23. redisReply* r = (redisReply*)redisCommand(c,command1);
24. //需要注意的是，如果返回的对象是NULL，则表示客户端和服务器之间出现严重错误，必须重新链接。
25. //这里只是举例说明，简便起见，后面的命令就不再做这样的判断了。
26. if
27. redisFree(c);
28. return;
29. }
30. //不同的Redis命令返回的数据类型不同，在获取之前需要先判断它的实际类型。
31. //至于各种命令的返回值信息，可以参考Redis的官方文档，或者查看该系列博客的前几篇
32. //有关Redis各种数据类型的博客。:)
33. //字符串类型的set命令的返回值的类型是REDIS_REPLY_STATUS，然后只有当返回信息是"OK"
34. //时，才表示该命令执行成功。后面的例子以此类推，就不再过多赘述了。
35. if (!(r->type == REDIS_REPLY_STATUS && strcasecmp(r->str,"OK") == 0)) {
36. "Failed to execute command[%s].\n",command1);
37. freeReplyObject(r);
38. redisFree(c);
39. return;
40. }
41. //由于后面重复使用该变量，所以需要提前释放，否则内存泄漏。
42. freeReplyObject(r);
43. "Succeed to execute command[%s].\n",command1);
44.
45. const char* command2 = "strlen stest1";
46. r = (redisReply*)redisCommand(c,command2);
47. if
48. "Failed to execute command[%s].\n",command2);
49. freeReplyObject(r);
50. redisFree(c);
51. return;
52. }
53. int
54. freeReplyObject(r);
55. "The length of 'stest1' is %d.\n",length);
56. "Succeed to execute command[%s].\n",command2);
57.
58. const char* command3 = "get stest1";
59. r = (redisReply*)redisCommand(c,command3);
60. if
61. "Failed to execute command[%s].\n",command3);
62. freeReplyObject(r);
63. redisFree(c);
64. return;
65. }
66. "The value of 'stest1' is %s.\n",r->str);
67. freeReplyObject(r);
68. "Succeed to execute command[%s].\n",command3);
69.
70. const char* command4 = "get stest2";
71. r = (redisReply*)redisCommand(c,command4);
72. //这里需要先说明一下，由于stest2键并不存在，因此Redis会返回空结果，这里只是为了演示。
73. if
74. "Failed to execute command[%s].\n",command4);
75. freeReplyObject(r);
76. redisFree(c);
77. return;
78. }
79. freeReplyObject(r);
80. "Succeed to execute command[%s].\n",command4);
81.
82. const char* command5 = "mget stest1 stest2";
83. r = (redisReply*)redisCommand(c,command5);
84. //不论stest2存在与否，Redis都会给出结果，只是第二个值为nil。
85. //由于有多个值返回，因为返回应答的类型是数组类型。
86. if
87. "Failed to execute command[%s].\n",command5);
88. freeReplyObject(r);
89. redisFree(c);
90. //r->elements表示子元素的数量，不管请求的key是否存在，该值都等于请求是键的数量。
91. assert(2 == r->elements);
92. return;
93. }
94. int
95. for
96. redisReply* childReply = r->element[i];
97. //之前已经介绍过，get命令返回的数据类型是string。
98. //对于不存在key的返回值，其类型为REDIS_REPLY_NIL。
99. if
100. "The value is %s.\n",childReply->str);
101. }
102. //对于每一个子应答，无需使用者单独释放，只需释放最外部的redisReply即可。
103. freeReplyObject(r);
104. "Succeed to execute command[%s].\n",command5);
105.
106. "Begin to test pipeline.\n");
107. //该命令只是将待发送的命令写入到上下文对象的输出缓冲区中，直到调用后面的
108. //redisGetReply命令才会批量将缓冲区中的命令写出到Redis服务器。这样可以
109. //有效的减少客户端与服务器之间的同步等候时间，以及网络IO引起的延迟。
110. //至于管线的具体性能优势，可以考虑该系列博客中的管线主题。
111. /* if (REDIS_OK != redisAppendCommand(c,command1)
112. || REDIS_OK != redisAppendCommand(c,command2)
113. || REDIS_OK != redisAppendCommand(c,command3)
114. || REDIS_OK != redisAppendCommand(c,command4)
115. || REDIS_OK != redisAppendCommand(c,command5)) {
116. redisFree(c);
117. return;
118. }
119. */
120.
121. redisAppendCommand(c,command1);
122. redisAppendCommand(c,command2);
123. redisAppendCommand(c,command3);
124. redisAppendCommand(c,command4);
125. redisAppendCommand(c,command5);
126. redisReply* reply = NULL;
127. //对pipeline返回结果的处理方式，和前面代码的处理方式完全一直，这里就不再重复给出了。
128. if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
129. "Failed to execute command[%s] with Pipeline.\n",command1);
130. freeReplyObject(reply);
131. redisFree(c);
132. }
133. freeReplyObject(reply);
134. "Succeed to execute command[%s] with Pipeline.\n",command1);
135.
136. if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
137. "Failed to execute command[%s] with Pipeline.\n",command2);
138. freeReplyObject(reply);
139. redisFree(c);
140. }
141. freeReplyObject(reply);
142. "Succeed to execute command[%s] with Pipeline.\n",command2);
143.
144. if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
145. "Failed to execute command[%s] with Pipeline.\n",command3);
146. freeReplyObject(reply);
147. redisFree(c);
148. }
149. freeReplyObject(reply);
150. "Succeed to execute command[%s] with Pipeline.\n",command3);
151.
152. if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
153. "Failed to execute command[%s] with Pipeline.\n",command4);
154. freeReplyObject(reply);
155. redisFree(c);
156. }
157. freeReplyObject(reply);
158. "Succeed to execute command[%s] with Pipeline.\n",command4);
159.
160. if (REDIS_OK != redisGetReply(c,(void**)&reply)) {
161. "Failed to execute command[%s] with Pipeline.\n",command5);
162. freeReplyObject(reply);
163. redisFree(c);
164. }
165. freeReplyObject(reply);
166. "Succeed to execute command[%s] with Pipeline.\n",command5);
167. //由于所有通过pipeline提交的命令结果均已为返回，如果此时继续调用redisGetReply，
168. //将会导致该函数阻塞并挂起当前线程，直到有新的通过管线提交的命令结果返回。
169. //最后不要忘记在退出前释放当前连接的上下文对象。
170. redisFree(c);
171. return;
172. }
173.
174. int
175. {
176. doTest();
177. return
178. }14.redis的数据类型及操作命令
redis支持的数据类型包括String、Hash、List、Set、Sorted Set，由于redis本质上一个key-value db，所以首先从Key开始学习。
Key(键)
key也是字符串类型，但是key中不能包括边界字符。
由于key不是binary safe的字符串，所以像"my key"和"mykey\n"这样包含空格和换行的key是不允许的。
顺便说一下在redis内部并不限制使用binary字符，这是redis协议限制的。"\r\n"在协议格式中会作为特殊字符。
关于key的一个格式约定介绍下，object-type:id:field。比如user:1000:password，blog:xxidxx:title
key的长度最好不要太长。道理很明显占内存啊，而且查找时候相对短key也更慢。不过也推荐过短的key，比如u:1000:pwd,这样的。显然没上面的user:1000:password可读性好。
下面介绍下key相关的几个命令，其他的请看相关文档：
命令 | 说明 | 示例 |
DEL key [key ...] | 移除给定的一个或多个key。如果key不存在，则忽略该命令。 | redis 127.0.0.1:6379> set name naxsu OK redis 127.0.0.1:6379> del name (integer) 1 |
KEYS pattern | 查找符合给定模式的key。 KEYS *命中数据库中所有key。 | redis 127.0.0.1:6379> mset one 1 two 2 three 3 four 4 OK redis 127.0.0.1:6379> keys * 1) "four" 2) "three" 3) "two" 4) "one" |
RANDOMKEY | 从当前数据库中随机返回(不删除)一个key。 | redis 127.0.0.1:6379> randomkey "two" |
TTL key | 返回给定key的剩余生存时间(time to live)(以秒为单位)，过期的key将被删除
| redis 127.0.0.1:6379> set name naxsu OK redis 127.0.0.1:6379> expire name 30 (integer) 1 redis 127.0.0.1:6379> ttl name (integer) 25 |
EXISTS key | 检查给定key是否存在，若key存在，返回1，否则返回0。 | redis 127.0.0.1:6379> exists name (integer) 0 redis 127.0.0.1:6379> exists one (integer) 1 |
RENAME key newkey | 将key改名为newkey。 当key和newkey相同或者key不存在时，返回一个错误。 当newkey已经存在时，RENAME命令将覆盖旧值。 | redis 127.0.0.1:6379> rename one newone |
TYPE key | 返回key所储存的值的类型 | redis 127.0.0.1:6379> type two string |
String(字符串)
string是redis最基本的类型，而且string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象。从内部实现来看其实string可以看作byte数组，最大上限是1G字节。下面是string类型的定义。
struct sdshdr {
long len;
long free;
char buf[];
};buf是个char数组用于存贮实际的字符串内容。其实char和c#中的byte是等价的，都是一个字节
len是buf数组的长度，free是数组中剩余可用字节数。由此可以理解为什么string类型是二进制安全的了。因为它本质上就是个byte数组，当然可以包含任何数据了。另外string类型可以被部分命令按int处理.比如incr等命令，下面详细介绍。还有redis的其他类型像list、set、sorted set、hash它们包含的元素与都只能是string类型。
下面介绍下String相关的一些命令，其他的请看相关文档：
命令 | 说明 | 示例 |
SET key value | 将字符串值value关联到key。 如果key已经持有其他值，SET就覆写旧值，无视类型。 | redis 127.0.0.1:6379> set name naxsu OK |
MSET key value [key value ...] | 同时设置一个或多个key-value对。 | redis 127.0.0.1:6379> mset one 1 two 2 three 3 four 4 OK |
APPEND key value | 如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值之后。 如果key不存在，APPEND就简单地将给定key设为value，就像执行SET key value一样。 | redis 127.0.0.1:6379> append name -neng (integer) 10 redis 127.0.0.1:6379> get name "naxsu-neng" |
GET key | 返回key所关联的字符串值。 | redis 127.0.0.1:6379> get name "naxsu-neng" |
STRLEN key | 返回key所储存的字符串值的长度 | redis 127.0.0.1:6379> strlen name (integer) 10 |
List(列表)
redis的list类型其实就是一个每个子元素都是string类型的双向链表。所以[lr]push和[lr]pop命令的算法时间复杂度都是O(1)
另外list会记录链表的长度。所以llen操作也是O(1).链表的最大长度是(2的32次方-1)。我们可以通过push,pop操作从链表的头部或者尾部添加删除元素。这使得list既可以用作栈，也可以用作队列。有意思的是list的pop操作还有阻塞版本的。当我们[lr]pop一个list对象时，如果list是空，或者不存在，会立即返回nil。但是阻塞版本的b[lr]pop可以则可以阻塞，当然可以加超时时间，超时后也会返回nil。为什么要阻塞版本的pop呢，主要是为了避免轮询。举个简单的例子如果我们用list来实现一个工作队列。执行任务的thread可以调用阻塞版本的pop去获取任务这样就可以避免轮询去检查是否有任务存在。当任务来时候工作线程可以立即返回，也可以避免轮询带来的延迟。
下面介绍下list相关的一些命令，其他的请看相关文档：
命令 | 说明 | 示例 |
LPUSH key value [value ...] | 将一个或多个值value插入到列表key的表头。 | redis 127.0.0.1:6379> LPUSH mylist a b c (integer) 3 |
RPUSH key value [value ...] | 将一个或多个值value插入到列表key的表尾。 | redis 127.0.0.1:6379> RPUSH mylist a b c (integer) 6[6个元素中包括上例PUSH的3个] |
LLEN key | 返回列表key的长度 | redis 127.0.0.1:6379> llen mylist (integer) 6 |
LRANGE key start stop | 返回列表key中指定区间内的元素，区间以偏移量start和stop指定。 | redis 127.0.0.1:6379> lrange mylist 0 6 1) "c" 2) "b" 3) "a" 4) "a" 5) "b" 6) "c" |
LPOP key | 移除并返回列表key的头元素 | redis 127.0.0.1:6379> lpop mylist "c" |
RPOP key | 移除并返回列表key的尾元素 | redis 127.0.0.1:6379> rpop mylist "c" |
Set(集合)
redis的set是string类型的无序集合。set元素最大可以包含(2的32次方-1)个元素。set的是通过hash table实现的，所以添加，删除，查找的复杂度都是O(1)。hash table会随着添加或者删除自动的调整大小。需要注意的是调整hash table大小时候需要同步（获取写锁）会阻塞其他读写操作。可能不久后就会改用跳表（skip list）来实现跳表已经在sorted set中使用了。关于set集合类型除了基本的添加删除操作，其他有用的操作还包含集合的取并集(union)，交集(intersection)，差集(difference)。通过这些操作可以很容易的实现sns中的好友推荐和blog的tag功能。
下面介绍下set相关的一些命令，其他的请看相关文档：
命令 | 说明 | 示例 |
SADD key member [member ...] | 将一个或多个member元素加入到集合key当中，已经存在于集合的member元素将被忽略 | redis 127.0.0.1:6379> sadd languages java c lisp python ruby (integer) 5 |
SMEMBERS key | 返回集合key中的所有成员 | redis 127.0.0.1:6379> smembers languages 1) "c" 2) "lisp" 3) "python" 4) "java" 5) "ruby" |
SREM key member [member ...] | 移除集合key中的一个或多个member元素 | redis 127.0.0.1:6379> srem languages lisp (integer) 1 |
SISMEMBER key member | 判断member元素是否是集合key的成员 | redis 127.0.0.1:6379> SISMEMBER languages php (integer) 0 |
SCARD key | 返回集合key的基数(集合中元素的数量) | redis 127.0.0.1:6379> SCARD languages (integer) 4 |
SINTER key [key ...] | 返回一个集合的全部成员，该集合是所有给定集合的交集 | redis 127.0.0.1:6379> sadd group_1 lilei tom jack (integer) 3 redis 127.0.0.1:6379> sadd group_2 naxsu jack (integer) 2 redis 127.0.0.1:6379> sinter group_1 group_2 1) "jack" |
SUNION key [key ...] | 返回一个集合的全部成员，该集合是所有给定集合的并集 | redis 127.0.0.1:6379> sunion group_1 group_2 1) "naxsu" 2) "lilei" 3) "tom" 4) "jack" |
SDIFF key [key ...] | 返回一个集合的全部成员，该集合是所有给定集合的差集 | redis 127.0.0.1:6379> SDIFF group_1 group_2 1) "lilei" 2) "tom" |
Sorted Set (有序集)
和set一样sorted set也是string类型元素的集合，不同的是每个元素都会关联一个double类型的score。
sorted set的实现是skip list和hash table的混合体,当元素被添加到集合中时，一个元素到score的映射被添加到hash table中，所以给定一个元素获取score的开销是O(1),另一个score到元素的映射被添加到skip list,并按照score排序，所以就可以有序的获取集合中的元素。添加，删除操作开销都是O(log(N))和skip list的开销一致,redis的skip list实现用的是双向链表,这样就可以逆序从尾部取元素。sorted set最经常的使用方式应该是作为索引来使用.我们可以把要排序的字段作为score存储，对象的id当元素存储。
下面介绍下sorted set相关的一些命令，其他的请看相关文档：
命令 | 说明 | 示例 |
ZADD key score member [[score member] [score member] ...] | 将一个或多个member元素及其score值加入到有序集key当中 | redis 127.0.0.1:6379> ZADD page_rank 9 baidu.com 8 bing.com 10 google.com (integer) 3 |
ZRANGE key start stop [WITHSCORES] | 返回有序集key中，指定区间内的成员, 其中成员的位置按score值递增(从小到大)来排序
ZREVRANGE key start stop [WITHSCORES] 其中成员的位置按score值递减(从大到小)来排列 | redis 127.0.0.1:6379> ZRANGE page_rank 0 -1 WITHSCORES 1) "bing.com" 2) "8" 3) "baidu.com" 4) "9" 5) "google.com" 6) "10" |
ZREM key member [member ...] | 移除有序集key中的一个或多个成员，不存在的成员将被忽略 | redis 127.0.0.1:6379> ZREM page_rank google.com (integer) 1 |
ZCARD key | 返回有序集key的基数 | redis 127.0.0.1:6379> zcard page_rank (integer) 2 |
ZCOUNT key min max | 返回有序集key中，score值在min和max之间(默认包括score值等于min或max)的成员 | redis 127.0.0.1:6379> zcount page_rank 7 9 (integer) 2 |
ZSCORE key member | 返回有序集key中，成员member的score值 | redis 127.0.0.1:6379> zscore page_rank baidu.com "9" |
Hash (哈希表)
redis hash是一个string类型的field和value的映射表.它的添加，删除操作都是O(1)（平均）.hash特别适合用于存储对象。相较于将对象的每个字段存成单个string类型。将一个对象存储在hash类型中会占用更少的内存，并且可以更方便的存取整个对象。省内存的原因是新建一个hash对象时开始是用zipmap（又称为small hash）来存储的。这个zipmap其实并不是hash table，但是zipmap相比正常的hash实现可以节省不少hash本身需要的一些元数据存储开销。尽管zipmap的添加，删除，查找都是O(n)，但是由于一般对象的field数量都不太多。所以使用zipmap也是很快的,也就是说添加删除平均还是O(1)。如果field或者value的大小超出一定限制后，redis会在内部自动将zipmap替换成正常的hash实现. 这个限制可以在配置文件中指定
hash-max-zipmap-entries 64 #配置字段最多64个
hash-max-zipmap-value 512 #配置value最大为512字节
下面介绍下hash相关的一些命令，其他的请看相关文档：
命令 | 说明 | 示例 |
HSET key field value | 将哈希表key中的域field的值设为value | redis 127.0.0.1:6379> hset website google www.google.com |
HGET key field | 返回哈希表key中给定域field的值 | redis 127.0.0.1:6379> hget website google "www.google.com" |
HDEL key field [field ...] | 删除哈希表key中的一个或多个指定域，不存在的域将被忽略 | redis 127.0.0.1:6379> hdel website google (integer) 1 |
HMSET key field value [field value ...] | 同时将多个field - value(域-值)对设置到哈希表key中 | redis 127.0.0.1:6379> HMSET website google www.google.com yahoo www.yahoo.com OK |
HMGET key field [field ...] | 返回哈希表key中，一个或多个给定域的值 | redis 127.0.0.1:6379> hmget website google yahoo 1) "www.google.com" 2) "www.yahoo.com" |
HGETALL key | 返回哈希表key中，所有的域和值 | redis 127.0.0.1:6379> hgetall website 1) "naxsu" 2) "www.naxsu.com" 3) "google" 4) "www.google.com" 5) "yahoo" 6) "www.yahoo.com" |
HLEN key | 返回哈希表key中域的数量 | redis 127.0.0.1:6379> hlen website (integer) 3 |
HEXISTS key field | 查看哈希表key中，给定域field是否存在 | redis 127.0.0.1:6379> HEXISTS website baidu (integer) 0 |
HKEYS key | 返回哈希表key中的所有域 | redis 127.0.0.1:6379> hkeys website 1) "naxsu" 2) "google" 3) "yahoo" |
HVALS key | 返回哈希表key中的所有值 | redis 127.0.0.1:6379> hvals website 1) "www.naxsu.com" 2) "www.google.com" 3) "www.yahoo.com" |
希望给读者带来帮助。
