Redis笔记——技术点汇总

目录

· 特点

· 安装

· 数据库

· 服务器命令

· 数据类型及其操作命令

· 数据结构

· string

· list

· set

· hash

· zset

· 发布与订阅

· 排序

· 事务

· pipeline

· 基准测试

· 键的过期

· 持久化

· 概况

· snapshoting

· AOF

· 主从复制

· HA

· Lua

· 示例：分布式日志

特点

1. Redis是一个开源的、C语言编写的、面向键值对类型数据的分布式NoSQL数据库系统。

2. 特点：高性能（内存数据库，随机读写非常快）、持久存储，适应高并发应用场景。

3. 对比：一些数据库和缓存服务器的特性与功能。

4. 性能测试结果：set操作每秒可达110000次，get操作每秒81000次（与服务器配置有关）。

安装

1. 安装。

tar zxvf redis-3.2.0.tar.gz
cd redis-3.2.0.tar.gz
yum install gcc # 安装依赖
cd deps
make hiredis lua jemalloc linenoise geohash-int
cd ..
make # 编译

2. 配置。

vi redis.conf

# bind 127.0.0.1 # 不绑定表示监听所有IP
protected-mode no # 无密码
daemonize yes # 后台运行
logfile "/opt/app/redis-3.2.0/logs/redis.log" # 日志文件路径
dir "/opt/app/redis-3.2.0/data/" # 快照文件路径
appendonly yes # 开启AOF

3. 启动、关闭。

src/redis-server redis.conf # 启动
src/redis-cli # 客户端
src/redis-cli shutdown # 关闭

数据库

1. Redis默认有16个数据库。

2. 数据库个数配置项：databases。

3. 切换数据库命令：

127.0.0.1:6379> select 0
OK
127.0.0.1:6379> select 15
OK
127.0.0.1:6379[15]>

服务器命令

数据类型及其操作命令

数据结构

1. 存储键与5种不同数据结构类型之间的映射。

2. 键是string类型。

3. 5种数据类型：string、list、set、hash、zset。

4. 命令：部分命令（如del、type、rename）对于5种类型通用；部分命令只能对特定的一种或者两种类型使用。另注：有很多命令尾部带“nx”表示不存在键时才执行。

5. 常用通用命令。

string

1. 可以是字符串、整数或浮点数。

2. Redis的字符串是由字节组成的序列。

3. 对于整数、浮点数的字符串可执行自增和自减；对无法解释成整数或浮点数的字符串执行自增或自减会返回错误。

4. 常用命令。

5. 举例。

127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> get hello
"world"
127.0.0.1:6379> del hello
(integer) 1
127.0.0.1:6379> get hello
(nil)
127.0.0.1:6379> set num 100
OK
127.0.0.1:6379> incrby num 10
(integer) 110
127.0.0.1:6379> append num abc
(integer) 6
127.0.0.1:6379> get num
"110abc"
127.0.0.1:6379> getrange num 2 4
"0ab"

list

1. Redis的list是链表（linked-list）。

2. 应用：列表、栈、队列、消息队列MQ等。

3. 命令。

4. 举例。

127.0.0.1:6379> rpush list-key item1
(integer) 1
127.0.0.1:6379> rpush list-key item2 item1
(integer) 3
127.0.0.1:6379> lpush list-key item0
(integer) 4
127.0.0.1:6379> lrange list-key 0 -1
1) "item0"
2) "item1"
3) "item2"
4) "item1"
127.0.0.1:6379> lindex list-key 3
"item1"
127.0.0.1:6379> lpop list-key
"item0"
127.0.0.1:6379> ltrim list-key 0 1
OK
127.0.0.1:6379> lrange list-key 0 -1
1) "item1"
2) "item2"

set

1. list允许有重复值，set不允许有重复值。

2. list是有序的，set是无序的。

3. set通过hash保证值不重复（这些hash表只有键，没有与键对应的值）。

4. 应用：去重列表、集合运算（交、并、差集）。

5. 命令。

6. 举例。

127.0.0.1:6379> sadd set-key item0
(integer) 1
127.0.0.1:6379> sadd set-key item1 item2
(integer) 2
127.0.0.1:6379> sadd set-key item0
(integer) 0
127.0.0.1:6379> smembers set-key
1) "item2"
2) "item1"
3) "item0"
127.0.0.1:6379> sismember set-key item3
(integer) 0
127.0.0.1:6379> sismember set-key item0
(integer) 1
127.0.0.1:6379> srem set-key item2
(integer) 1
127.0.0.1:6379> srem set-key item2
(integer) 0
127.0.0.1:6379> smembers set-key
1) "item1"
2) "item0"

hash

1. Redis的散列可以存储多个键值对之间的映射，在很多方面就像是一个微缩版的Redis。

2. 命令。

3. 举例。

127.0.0.1:6379> hset hash-key sub-key0 value0
(integer) 1
127.0.0.1:6379> hset hash-key sub-key1 value1
(integer) 1
127.0.0.1:6379> hmset hash-key sub-key2 value2 sub-key3 value3
OK
127.0.0.1:6379> hset hash-key sub-key0 value0
(integer) 0
127.0.0.1:6379> hgetall hash-key
1) "sub-key0"
2) "value0"
3) "sub-key1"
4) "value1"
5) "sub-key2"
6) "value2"
7) "sub-key3"
8) "value3"
127.0.0.1:6379> hdel hash-key sub-key3
(integer) 1
127.0.0.1:6379> hmget hash-key sub-key0 sub-key1
1) "value0"
2) "value1"
127.0.0.1:6379> hget hash-key sub-key2
"value2"
127.0.0.1:6379> hkeys hash-key
1) "sub-key0"
2) "sub-key1"
3) "sub-key2"
127.0.0.1:6379> hvals hash-key
1) "value0"
2) "value1"
3) "value2"

4. 应用：可以把hash看作关系数据库的行，hash中的key为字段名，hash中的value为字段值。以用户为例，新增/查询ID为1和2的两个用户：

127.0.0.1:6379> hmset user:1 name zhangsan age 18
OK
127.0.0.1:6379> hmset user:2 name lisi age 19
OK
127.0.0.1:6379> hgetall user:1
1) "name"
2) "zhangsan"
3) "age"
4) "18"
127.0.0.1:6379> hgetall user:2
1) "name"
2) "lisi"
3) "age"
4) "19"

zset

1. zset和hash一样，都用于存储键值对。

2. zset的键称为成员（member），不允许重复。

3. zset的值称为分值（score），必须是浮点数。

4. zset既可以根据member访问元素（与hash相同），也可以根据分值及分值的排序顺序来访问元素。

5. 应用：排序、去重。

6. 命令。

7. 举例。

127.0.0.1:6379> zadd zset-key 200 member1
(integer) 1
127.0.0.1:6379> zadd zset-key 300 member0 400 member2
(integer) 2
127.0.0.1:6379> zadd zset-key 100 member1
(integer) 0
127.0.0.1:6379> zcard zset-key
(integer) 3
127.0.0.1:6379> zcount zset-key 100 350
(integer) 2
127.0.0.1:6379> zrank zset-key member1
(integer) 0
127.0.0.1:6379> zrank zset-key member1
(integer) 0
127.0.0.1:6379> zscore zset-key member1
"100"
127.0.0.1:6379> zrange zset-key 1 2
1) "member0"
2) "member2"
127.0.0.1:6379> zrevrank zset-key member1
(integer) 2
127.0.0.1:6379> zrevrange zset-key 1 2
1) "member0"
2) "member1"
127.0.0.1:6379> zrangebyscore zset-key 100 350
1) "member1"
2) "member0"
127.0.0.1:6379> zrevrangebyscore zset-key 100 350
(empty list or set)
127.0.0.1:6379> zrevrangebyscore zset-key 350 100
1) "member0"
2) "member1"

8. zinterstore交集举例。

9. zunionstore并集举例。

发布与订阅

1. 发布与订阅（pub/sub）的特点是订阅者（listener）负责订阅频道（channel），发送者（publisher）负责向频道发送二进制字符串消息（binary string message）。

2. 当有消息被发送至给定频道时，频道的所有订阅者都会收到消息。

3. 备注：将list作为队列，同时使用阻塞命令同样可以实现发布/订阅，具体代码参见“示例：分布式日志”。

4. 命令。

5. 举例。

127.0.0.1:6379> subscribe channel0 channel1
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "channel0"
3) (integer) 1
1) "subscribe"
2) "channel1"
3) (integer) 2
1) "message"
2) "channel0"
3) "hello"
1) "message"
2) "channel1"
3) "world"

127.0.0.1:6379> publish channel0 hello
(integer) 1
127.0.0.1:6379> publish channel1 world
(integer) 1

6. 订阅者读取速度。

a) 问题：如果订阅者读取消息速度不够快，那么不断积压的消息会使Redis输出缓冲区的体积越来越大，可能会导致Redis速度变慢，甚至崩溃。

b) 解决：自动断开不符合client-output-buffer-limit pubsub配置选项的订阅客户端。

7. 数据传输可靠性。

a) 问题：网络连接错误会使网络连接两端中的其中一端重新连接，导致客户端丢失在短线期间的所有消息。

b) 解决：TODO 第六章两个不同方法。

排序

1. 对list、set、zset排序。

2. 命令。

3. 举例。

127.0.0.1:6379> rpush sort-key v1 v0 v3 v4 v2
(integer) 5
127.0.0.1:6379> sort sort-key alpha
1) "v0"
2) "v1"
3) "v2"
4) "v3"
5) "v4"
127.0.0.1:6379> sort sort-key alpha desc
1) "v4"
2) "v3"
3) "v2"
4) "v1"
5) "v0"

事务

1. Redis的基本事务（basic transaction）可以让一个客户端在不被其他客户端打断的情况下执行多个命令。

2. 与关系数据库不同，Redis的基本事务在执行完事务内所有命令后，才会处理其他客户端的命令。

3. 命令。

4. 举例。

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k0 v0
QUEUED
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK

127.0.0.1:6379> watch k0 k1
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k0 v0x
QUEUED
127.0.0.1:6379> set k1 v1x
QUEUED
127.0.0.1:6379> exec

5. Redis事务内有部分命令失败时，整个事务不会自动discard，导致事务内可能部分命令成功，部分失败。举例：

127.0.0.1:6379> set str-key halo
OK
127.0.0.1:6379> set num-key 100
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incr str-key
QUEUED
127.0.0.1:6379> incr num-key
QUEUED
127.0.0.1:6379> exec
1) (error) ERR value is not an integer or out of range
2) (integer) 101
127.0.0.1:6379> get str-key
"halo"
127.0.0.1:6379> get num-key
"101"

pipeline

1. 应用程序连接Redis执行事务及事务中所有命令（5个）时，一定要使用pipeline。

2. 由于pipeline会一次发送所有命令，可减少通信次数并降低延迟，在非事务时也推荐使用。

基准测试

1. Redis附带基准测试程序redis-benchmark。

2. 举例：模拟单个客户端。

src/redis-benchmark -c 1 -q
PING_INLINE: 77399.38 requests per second
PING_BULK: 81566.07 requests per second
SET: 58513.75 requests per second
GET: 80840.74 requests per second
INCR: 57208.24 requests per second
LPUSH: 54229.93 requests per second
RPUSH: 55555.56 requests per second
LPOP: 55401.66 requests per second
RPOP: 57937.43 requests per second
SADD: 77459.34 requests per second
SPOP: 79113.92 requests per second
LPUSH (needed to benchmark LRANGE): 54495.91 requests per second
LRANGE_100 (first 100 elements): 37271.71 requests per second
LRANGE_300 (first 300 elements): 16537.13 requests per second
LRANGE_500 (first 450 elements): 11799.41 requests per second
LRANGE_600 (first 600 elements): 9273.00 requests per second
MSET (10 keys): 31735.96 requests per second

3. 应用程序在使用pipeline和连接池的情况下，基本与上面模拟的测试性能一致。

键的过期

1. 设置键的过期时间，让键在在给定的时限后自动被删除（相当于执行del命令）。

2. 只能设置整个键的过期时间（支持5中数据结构），无法设置list、set、hash和zset中单个元素的过期时间。

3. 命令。

4. 举例。

127.0.0.1:6379> set expire-key v
OK
127.0.0.1:6379> ttl expire-key
(integer) -1
127.0.0.1:6379> expire expire-key 10
(integer) 1
127.0.0.1:6379> ttl expire-key
(integer) 7
127.0.0.1:6379> get expire-key
(nil)

持久化

概况

1. 两种持久化方式：

a) snapshoting（快照）：将某一时刻内存中所有数据写入硬盘；

b) AOF（append-only file）：执行写入命令时，将命令追加到硬盘文件。

2. 两种持久化方式可同时使用，也可单独使用，某些情况下也可以两种都不使用。

3. 配置。

save 60 1000 # snapshoting配置
stop-writes-on-bgsave-error no
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb

appendonly no # AOF配置
appendfilename "appendonly.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes

dir ./ # 共用配置

snapshoting

1. 创建snapshoting的方法/时机。

a) 执行bgsave命令。Redis会调用fork创建一个子进程，子进程负责将快照写入硬盘，父进程继续处理命令请求。

b) 执行save命令。Redis在创建快照完成之前不再响应任何其他命令。不常用，通常只会在内存不足时使用。

c) 设置save配置。“save 60 100000”表示当满足“60秒之内有10000次写入”条件时，自动触发bgsave命令。如果有多个save配置，那么任意一个条件满足时都会触发。

d) 执行shutdown命令或收到标准term信号时，会先触发save命令（不再响应任何客户端请求）。

e) 一个Redis服务器连接另一个Redis服务器，并向对方发送sync命令开始一次复制时，如果主服务器目前没有执行bgsave命令，或主服务器并非刚刚执行完bgsave命令，那么主服务器会执行gbsave命令。

2. snapshoting注意：如果系统真的发生崩溃，将丢失最近一次生成快照后更新的所有数据。

3. snapshoting与大数据：如果Redis内存占用高达几十GB，并且空闲内存不多，或者硬件性能较差时，执行bgsave命令可能会导致长时间停顿（几秒，甚至几十分钟），也可能引发系统大量使用虚拟内存，从而导致Redis性能降低至无法使用。

AOF

1. appendfsync同步频率。

a) always。每个写命令都同步写入硬盘。严重降低Redis性能。降低固态硬盘SSD寿命。

b) everysec。每秒同步一次，将多个写命令同步到硬盘。兼顾数据安全和写入性能。

c) no。让操作系统决定何时同步。一般不影响性能，但崩溃将导致不定数量的数据丢失。不推荐。

2. 重写AOF文件：移除AOF文件中的冗余命令，压缩AOF文件体积。

3. 重写AOF文件解决的问题。

a) 随着Redis不断运行，AOF文件不断增大，极端时甚至用完硬盘空间。

b) Redis重启后需要重新执行AOF文件中的写命令还原数据，如果AOF文件非常大，那么还原时间可能会非常长。

4. 重写AOF文件的方法/时机。

a) 执行bgrewriteaof命令。与bgsave命令相似，Redis会创建一个子进程负责AOF文件重写，也存在影响性能的问题。

b) 设置auto-aof-rewrite-percentage和auto-aof-rewrite-min-size配置。“auto-aof-rewrite-percentage 100”和“auto-aof-rewrite-min-size 64mb”表示当AOF文件大于64MB且AOF文件比上次重写后至少大一倍（100%）时，触发bgrewriteaof命令。

主从复制

1. 解决：虽然Redis性能优秀，但也会有无法快速处理请求的情况。伸缩（scalability）。

2. 客户端效果：客户端每次向主服务器执行写入命令时，从服务器都会实时更新，客户端就可以向任意一个服务器执行读取命令。

3. 配置：

a) 主服务器设置dir和dbfilename配置。保证从服务器连接主服务器时，主服务器能执行bgsave操作。

b) 从服务器设置slaveof host port配置，或执行slaveof host port命令。让从服务器复制主服务器。slaveof no one命令可终止复制。

4. 从服务器连接主服务器的过程。

5. 优化：实际中最好让主服务器只使用50%~65%的内存，剩余30%~45%内存用于执行bgsave命令和创建记录写命令的缓冲区。

6. 主从链：从服务器也可以拥有自己的从服务器，由此形成主从链（master/slave chaning）。

7. 主从链解决问题。

a) 读请求远多于写请求。

b) 负荷上升，主服务器无法快速更新所有从服务器。

8. 主从链结构：不一定是树状结构。

9. 更换故障主服务器步骤：

a) 从服务器执行save命令，生成最新快照文件；

b) 将快照文件复制到新主服务器；

c) 配置并启动新主服务器；

d) 从服务器连接新主服务器。

HA

1. Redis-Sentinel是Redis的Master-Slave高可用方案。

2. Master宕机时，自动完成主备切换。

3. 资料：http://redis.cn/topics/sentinel.html。

Lua

1. Redis中的Lua类似关系数据库中的存储过程，可封装逻辑。

2. Lua脚本跟单个Redis命令以及“multi/exec”事务一样，都是原子操作，因此可替代事务。

3. 命令。

4. 举例（第3个证明脚本中Redis命令执行失败时不会discard已执行过的命令，即“事务”提到的第5点）。

$ redis-cli eval "return ‘Hello World‘" 0
"Hello World"

$ redis-cli eval "return {KEYS[1], KEYS[2], ARGV[1], ARGV[2]}" 2 key1 key2 arg1 arg2
1) "key1"
2) "key2"
3) "arg1"
4) "arg2"

$ vi test.lua
local ret = redis.call("set", KEYS[1], ARGV[1])
if redis.call("exists", KEYS[2]) == 1 then
  redis.call("incr", KEYS[2])
else
  redis.call("set", KEYS[2], ARGV[2])
end
return ret
$ redis-cli script load "$(cat test.lua)"
"07aa590946287d9ae0c3df41dd9ba06a64280d85"
$ redis-cli evalsha 07aa590946287d9ae0c3df41dd9ba06a64280d85 2 mykey1 mykey2 myarg1 myarg2
OK
$ redis-cli evalsha 07aa590946287d9ae0c3df41dd9ba06a64280d85 2 mykey1 mykey2 myarg1111111 myarg2
(error) ERR Error running script (call to f_07aa590946287d9ae0c3df41dd9ba06a64280d85): @user_script:3: ERR value is not an integer or out of range
$ redis-cli get mykey1
"myarg1111111"
$ redis-cli get mykey2
"myarg2"

示例：分布式日志

1. 生产者-消费者模式。

2. 多台机器将日志保存到Redis队列，一个线程从该队列取出日志并保存到日志文件。个数比：生产者:消费者=N:1。

3. 代码（使用Jedis API）：

  1 import static gz.redis.DistributedLog.HOST;
  2 import static gz.redis.DistributedLog.LOG_QUEUE_KEY;
  3 import static gz.redis.DistributedLog.PORT;
  4 import static gz.redis.DistributedLog.connection;
  5
  6 import java.io.BufferedWriter;
  7 import java.io.FileWriter;
  8 import java.io.IOException;
  9 import java.util.Date;
 10 import java.util.List;
 11 import java.util.UUID;
 12 import java.util.concurrent.ExecutorService;
 13 import java.util.concurrent.Executors;
 14
 15 import redis.clients.jedis.Jedis;
 16 import redis.clients.jedis.JedisPool;
 17 import redis.clients.jedis.JedisPoolConfig;
 18
 19 public class DistributedLog {
 20
 21     static final String HOST = "centos1";
 22
 23     static final int PORT = 6379;
 24
 25     private static JedisPool jedisPool;
 26
 27     static final String LOG_QUEUE_KEY = "log-queue";
 28
 29     public static void main(String[] args) {
 30         initConnectionPoll();
 31
 32         ExecutorService threadPool = Executors.newFixedThreadPool(50);
 33         for (int index = 0; index < 500000; index++) {
 34             threadPool.execute(new Writer());
 35         }
 36         new Thread(new Processor()).run();
 37         threadPool.shutdown();
 38     }
 39
 40     private static void initConnectionPoll() {
 41         if (jedisPool == null) {
 42             JedisPoolConfig config = new JedisPoolConfig();
 43             config.setMaxTotal(51);
 44             config.setMinIdle(51);
 45             config.setMaxIdle(51);
 46             config.setMaxWaitMillis(60 * 1000);
 47             config.setTestOnCreate(true);
 48             config.setTestOnReturn(true);
 49             config.setTestOnBorrow(true);
 50             config.setTestWhileIdle(true);
 51             jedisPool = new JedisPool(config, HOST, PORT);
 52         }
 53     }
 54
 55     static Jedis connection() {
 56         return jedisPool.getResource();
 57     }
 58
 59 }
 60
 61 class Writer implements Runnable {
 62
 63     @Override
 64     public void run() {
 65         String log = new Date() + " - " + UUID.randomUUID() + "\n";
 66         Jedis jedis = null;
 67         try {
 68             jedis = connection();
 69             // 队尾追加
 70             jedis.rpush(LOG_QUEUE_KEY, log);
 71         } finally {
 72             if (jedis != null) {
 73                 jedis.close();
 74             }
 75         }
 76     }
 77
 78 }
 79
 80 class Processor implements Runnable {
 81
 82     @Override
 83     public void run() {
 84         BufferedWriter writer = null;
 85         Jedis jedis = null;
 86         try {
 87             writer = new BufferedWriter(new FileWriter("D:/movie/MyTest.log"));
 88             jedis = new Jedis(HOST, PORT);
 89             int count = 0;
 90             while (true) {
 91                 // 队头取出，无限时间阻塞，直至取出
 92                 List<String> logs = jedis.blpop(0, LOG_QUEUE_KEY);
 93                 if (logs != null && logs.size() >= 2) {
 94                     writer.write(logs.get(1));
 95                     if (++count > 100) {
 96                         writer.flush();
 97                     }
 98                 }
 99             }
100         } catch (IOException e) {
101             e.printStackTrace();
102         } finally {
103             if (jedis != null) {
104                 jedis.close();
105             }
106             if (writer != null) {
107                 try {
108                     writer.close();
109                 } catch (IOException e) {
110                     e.printStackTrace();
111                 }
112             }
113         }
114     }
115
116 }

作者：netoxi
出处：http://www.cnblogs.com/netoxi
本文版权归作者和博客园共有，欢迎转载，未经同意须保留此段声明，且在文章页面明显位置给出原文连接。欢迎指正与交流。