Redis学习

目录

 

1，什么是Redis？

Redis的特点：

Redis能干什么？

2，Redis基础知识

3，Redis为什么比较快？

        Redis的线程模型

4，Redis的数据类型

Redis 支持五大数据类型：

下面给出一些常用命令

5，Redis的缓存过期策略和内存淘汰机制

删除策略:

内存淘汰机制

maxmemory-policy volatile-lru-》内存淘汰机制

6，Redis的持久化

RDB

AOF

7，Redis的主从复制

8，Redis的事务

---

1，什么是Redis？

Redis是高性能的key/value内存数据库，基于内存运行。

Redis的特点：

                        1，Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用

                        2，Redis不仅仅支持简单的Key/value类型的数据，同时还提供list，set，zset，等数据类型

                        3，Redis支持数据的备份，既master-slave模式的数据备份   

Redis能干什么？

    1，内存存储和持久化：支持异步将内存中的数据写到硬盘上，同时不影响继续服务

    2，取最新N个数据的操作：如可以将最近的10条评论放在redis的list集合中

    3，模拟类似于httpsession这种需要设定设定过期时间的功能

    4，发布、订阅消息系统

    5，定时器，计数器

2，Redis基础知识

   1，单进程模型来处理客户端的请求，对读写事件的响应，通过epoll函数（多路io复用）的包装来做到的，Redis的实际处理速度完成依靠主进程的执行效率

   2，默认16个数据库，类似数组下标从0开始

   3，select 命令切换数据库

   4，dbsize查看当前数据库key的数量

   5，flushDB：清空当前库

   6，flushAll：清空所有库

   7，统一密码管理：16个库都是同样密码，要么都ok，要么一个都连接不上

   8，Redis索引是从0开始的

   9，Redis的默认端口是6379

3，Redis为什么比较快？

   1，基于内存操作，所以速度比较快

   2，Redis的单线程模型，避免了频繁的上下文切换，主要是采用了IO多路复用

         IO多路复用

Redis的线程模型

redis 内部使用文件事件处理器 file event handler，这个文件事件处理器是单线程的，所以 redis 才叫做单线程的模型。

它采用 IO 多路复用机制同时监听多个 socket，根据 socket 上的事件来选择对应的事件处理器进行处理。

文件事件处理器的结构包含 4 个部分：

• 多个 socket

• IO 多路复用程序

• 文件事件分派器

• 事件处理器（连接应答处理器、命令请求处理器、命令回复处理器）

多个 socket 可能会并发产生不同的操作，每个操作对应不同的文件事件，但是 IO 多路复用程序会监听多个 socket，会将 socket 产生的事件放入队列中排队，事件分派器每次从队列中取出一个事件，把该事件交给对应的事件处理器进行处理。

4，Redis的数据类型

Redis 支持五大数据类型：

1，String      2，List      3，Set      4，Hash      5，Sorted set

String：redis的基本类型，一个key对应一个value。String类型是二进制安全的，意思是redis的String可以包含任何数据，比如图片或者序               列化的对象。一个redis中字符串value最多可 以是512M。

应用场景：一般做一些计数功能的缓存

Hash（类似于java里的Map）：是一个键值对集合，是一个String类型的filed和value的映射 表，hash特别适合用于存储对象。

应用场景：可在登录时存储用户信息及它的token

List：底层是一个链表。按照插入顺序排序，你可以添加一个元素在头部或者尾部

应用场景：使用 List 的数据结构，可以做简单的消息队列的功能。另外还有一个就是，可以利用 lrange 命令，做基于 Redis 的分页功能。

Set：String类型下的无序，无重复的集合

应用场景：可以进行去重，还可以利用交集、并集、差集等操作，可以计算共同喜好，全部的喜好，自己独有的喜好等功能。

Sorted set：有序集合，每一个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。                                  sorted set的成员是唯一的，但分数却可以重复
应用场景：可以做排行榜应用

Redis命令参考大全——http://redisdoc.com/

下面给出一些常用命令

key

Exists key：判断有没有这个key  返回0无 1有

move key 2:将key移到2号库

keys *：查找所有key

expire key 秒钟：为给定的key设置过期时间

ttl key：查看还有多少秒过期，-1表示永不过期，-2表示已过期

type key：查看key是什么类型

del key：删除key

String

set/get/del/append/strlen ：append key 12 拼接字符串     strlen 字符串长度

incr/decr/incrby/decrby: 加减，一定要是数字的加减，incrby/decrby保证了原子性

getrange：获取指定区间范围内的值，类似于between and的关系 从0到-1表示全部

setrange：设置指定区间范围内的值，格式是setrange key 0  xxx：从0位开始设置XXX

setex/setnx： setex  k4 10 v4 让k4活十秒    setnx k4 10 v4  如果不存在才设置

mset k1 v1 k2 v2 k3 v3   一下设置很多   mget k1 k2 k3   

msetnx k1 v1 k2 v2 k3 v3   先判断key是否存在，存在再设置  如果有一个存在就全部失效

List  单值多value

Lpush list1 1 2 3 4 5  从左边进  LRange list 0 -1 查找list1 的全部

RPush 是从右边进

lpop  rpop  出

lindex 0 2  2 号位

llen  长度

lrem key 删n个value的值 lrem list 2 3 在这个list里面上删除2个3

ltrim key开始index结束index  ，截取指定范围的值后再赋值给key

rpoplpush 源列表 目的列表    将第一个list的最右边移到list2的最左边

lset key index value  将index的值改成value

linsert key before /after 值1 值2   在值1前或者后插入值2

字符串链表 左右都可以插入 如果键不存在创建新的链表，键存在新增内容  对中间元素修改比较慢一点

set去重

sadd/smembers/sismember：添加元素/获取元素

scard：获取集合里面的元素 个数

srem  key value：删除集合中元素

srandmember key 随机出几个数

spop key随机出栈

smove key1 key2 值   将key1里的某个值赋给key2

差集 sdiff  list1 list2 

交集 sinter list1 list2 

并集 sunion list1 list2 

hash kv模式不变 但v是一个键值对

hset key id 1/hget/hmset/hmget/hgetall/hdel

hlen：长度 

hexists key：key是否存在

hkeys：查看所有key

hvals：查看所有value

hincry hincryfloat

Sorted Set 

在sort基础上，加一个score值 。score是为了进行排序

 k1 score1 v1

zadd zset1 60 v1  70 v2 80 v3

zrange zset1 0 -1

zrangebysocre key 60 90   60 到90的  （90：就是不包含90

zrem key  v5

zcard：返回 有序集合中数据的数量

zcount zset1 60 80  统计60~80个数

zrank zset1 v4 获取

ZSCORE key member：返回key对应的有序集合某一member对应score的值。

ZRANGE key start stop：key对应的有序集合按照score从小到大的顺序，返回索引在start和stop之间的数据。

ZREVRANGE key start stop：key对应的有序集合按照score从大到小的顺序，返回索引在start和stop之间的数据。

5，Redis的缓存过期策略和内存淘汰机制

我们都知道，删除键的目的，就是释放内存占用。那么，当一个键过期了，Redis 什么时候会去删除它呢？

删除策略:

1，定时删除

设置键的过期时间时，创建一个 Timer ，当过期时间到临时，立刻删除键。

内存友好型策略，一旦键过期，就会被删除，并释放所占用的内存，Cpu 不友好，当一批数量比较多的键过期时，正好遇上Cpu 紧张的时段，这时候需要的是Cpu处理能力，而不是内存，显然 Cpu 时间用在删除过期键上，会对服务器的响应时间和吞吐量造成影响。另外当前 Redis 时间事件（无序链表O(N)）无法高效处理大量时间事件，所以定时删除并不是一种好的删除策略。

2，惰性删除

当键在键空间中被取出时，首先检查取出的键是否过期，若过期删除该键，否则，返回该键。

惰性删除依赖过期键的被动访问，对于内存不友好，如果一些键长期没有被访问，会造成内存泄露（垃圾数据占用内存）。所以惰性删除也不是一个好的策略。

3，定期删除

定期删除，Redis 默认每个 100ms 检查，是否有过期的 Key，有过期 Key 则删除。

需要说明的是，Redis 不是每个 100ms 将所有的 Key 检查一次，而是随机抽取进行检查

Redis采用的是定期删除+惰性删除的方式

因为定期删除会导致很多没用的key没有被删除，所以还是得加上惰性删除方式。

但是采用这种方式，如果你定期没有删除，也没有去访问这个key，那么也会造成内存泄漏，所以就需要内存淘汰机制。

内存淘汰机制

在 redis.conf 中有一行配置：

maxmemory-policy volatile-lru-》内存淘汰机制

redis.conf 中的过期淘汰配置
# MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
# is reached. You can select among five behaviors:
#最大内存策略：当到达最大使用内存时，你可以在下面5种行为中选择，Redis如何选择淘汰数据库键

#当内存不足以容纳新写入数据时

# volatile-lru -> remove the key with an expire set using an LRU algorithm
# volatile-lru ：在设置了过期时间的键空间中，移除最近最少使用的key。这种情况一般是把 redis 既当缓存，又做持久化存储的时候才用。

# allkeys-lru -> remove any key according to the LRU algorithm
# allkeys-lru ： 移除最近最少使用的key （推荐）

# volatile-random -> remove a random key with an expire set
# volatile-random ： 在设置了过期时间的键空间中，随机移除一个键，不推荐

# allkeys-random -> remove a random key, any key
# allkeys-random ： 直接在键空间中随机移除一个键

# volatile-ttl -> remove the key with the nearest expire time (minor TTL)
# volatile-ttl ： 在设置了过期时间的键空间中，有更早过期时间的key优先移除 不推荐

# noeviction -> don't expire at all, just return an error on write operations
# noeviction ： 不做过键处理，只返回一个写操作错误。 不推荐

# Note: with any of the above policies, Redis will return an error on write
#       operations, when there are no suitable keys for eviction.
# 上面所有的策略下，在没有合适的淘汰删除的键时，执行写操作时，Redis 会返回一个错误。下面是写入命令：
#       At the date of writing these commands are: set setnx setex append
#       incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
#       sinter sinterstore sunion sunionstore sdiff sdiffstore zadd zincrby
#       zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
#       getset mset msetnx exec sort

6，Redis的持久化

Redis的持久化分为RDB和AOF

RDB

是指在指定的时间间隔内将内存中的数据集快照写入磁盘，实际操作过程是fork一个子进程，先将数据集写入临时文件，写入成功后，再替换之前的文件，用二进制压缩存储。rdb保存在dump.rdb中

持久化时机：

1，如果满足其中一个就会进行RDB持久化

    save 900 1  900秒1次

    save 300 10  300秒10次

    save 60 10000  60秒一万次

2，命令save bgsave会立马存储dump 

    save：只管保存，其他不管，全部阻塞

    bgsave：redis在 后台异步进行快照操作，快照同时还可以响应客户端请求，可以通过 lastsave命令获取最后一次成功执行快照的时间

3，执行flushall命令也会产生dump文件

优点：适合大规模的数据恢复，对数据完整性和一致性要求不高

缺点：在dump之前挂了，最后一次存的东西会丢失，fork的时候，内存中的数据被克隆了一份 ，要占内存空间

AOF

AOF；以日志的形式来记录每个写操作 ，将Redis执行过的所有写指令记录下下来（读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作

默认存储文件  apendonly.aof

默认是关闭的，需要开启

安全问题：
        虽然服务器执行一个修改数据库的命令，就会被执行的命令写入到AOF文件，但这并不意味着AOF文件持久化不会丢失任何数据。

        在目前常见的操作系统中，执行系统调用write函数，将一些内容写入到某个文件里面时，为了提高效率，系统通常不会直接将内容写入到硬盘里面，而是先将内容放在一个内存缓冲区(buffer)里面，等到缓冲区被填满，或者用户执行fsync调用和fdatasync调用时才将储存在缓冲区里面的内容真正的写入到硬盘里。

         对于AOF持久化而言，当一条命令真正的被写入到硬盘里面时，这条命令才不会因为停机而意外丢失。

        因此，AOF持久化在遭遇停机时丢失命令的数量，取决于命令被写入到硬盘的时间。

AOF持久化配置

在Redis的配置文件中存在三种同步方式，它们分别是：

appendfsync always     #每次有数据修改发生时都会写入AOF文件。

appendfsync everysec  #每秒钟同步一次，该策略为AOF的缺省策略。

appendfsync no          #从不同步。高效但是数据不会被持久化。

aof文件被破坏，可以使用Redis-check-aof  （在 bin目录下）来修复

AOF-Rewrite

AOF越写越多，文件越来越大，所以就新增了重写机制，当AOF的大小超过所设定的阈值 时，Redis就会启动AOF文件的内容压缩，只保留可以恢复数据的最小指令集，可以使用命令bgrewriteaof

AOF文件持续增长而过大时，会fork一个新进程来将文件重写（也是先写临时文件最后再rename），遍历新进程的内存中数据，每条记录有一条set语句，重写aof文件的操作，没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件.rewrite过程中，对于新的变更操作将仍然被写入到原AOF文件中，同时这些新的变更操作也会被redis收集起来.当内存数据被全部写入到新的aof文件之后，收集的新的变更操作也将会一并追加到新的aof文件中，此后将会重命名新的aof文件为appendonly.aof,此后所有的操作都将被写入新的aof文件。如果在rewrite过程中，出现故障，将不会影响原AOF文件的正常工作，只有当rewrite完成之后才会切换文件，因为rewrite过程是比较可靠的

AOF和RDB可以同时存在吗？

可以，但是默认使用的AOF

优点：灵活的配置，有三种配置，各有各的优点

缺点：相同数据集的数据而言，aof文件大于rdb，aof运行效率慢与rdb

7，Redis的主从复制

Redis主从复制/读写分离是什么？

    主机数据更新后根据配置和策略，自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主

能干嘛？

    读写分离 容灾恢复

怎么玩？

    1，配从不配主

    2，从库配置：Slaveof 主库IP 主库端口  每次与master断开之后，都需要重新连接，除非配置进redis.conf文件

    3，修改配置文件

    4，常用3招：

            一主二从：一个主机两个从机

            薪火相传：主机宕机后，会从从机中随机抽取一台作为新的主机

            反客为主：这个主机再次回来后，只能作为从机了。

复制原理：Slave启动成功后连接到master后会发送一个sync命令

                Master接到命令后启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕后，master 将传送                  整个数据文件到slave，完成一次同步 .

                全量复制：slave服务在接收到数据库文件数据后，将其存盘并加载到内存中

                增量复制：master继续讲新的所有收到的修改命令依次传送给salve，完成同步 

                但是只要重新连接上master，全量复制将被自动执行

                首次全量，之后增量

哨兵模式 （反客为主的自动版）

                能够后台监控主机是否故障 。主机挂了，在剩余从机中投票选出一个作为新的主机

                1，首先先保持一主二从结构

                2，建立sentinel.conf配置文件

                3，配置哨兵，填写内容 sentinel monitor 被监控数据库名字  127.0.0.1 6379 1

                                        1代表主机挂掉后slave投票看让谁接替成为主机，得票数多少后成为主机

                4，启动哨兵    redis-sentinel /sentinel mointor

主从复制的缺点：

        由于写操作都是先在Master上操作，然后同步更新到slave上，所以从master同步到slave机器中有一定的延迟，当系统很繁忙的时候，延迟问题会更加严重，slave机器数量的增加也会使这个问题更加严重.

8，Redis的事务

Redis的事务并不像是关系型数据库中的ACID，而是保证在一个队列中，一次性，顺序性，排他性的执行一系列命令。

Redis 事务命令：

1，discard :取消事务，放弃执行事务块内的所有命令

2，exec：执行所有事务块内的命令

3，multi：标记一个事务块的开始

4，unwatch：取消watch命令对所有key的监视

5，watch key：监视一个或多个key，如果在事务执行之前，这个 key被其他命令所改动，那么事务被打断

watch指令，类似于乐观锁，事务提交时，如果key的值已被别的客户端 改变，比如某个list已被别的客户端push/pop过，整个事务队列都不会被执行。

但是redis对事务的支持是部分支持

比如：

incr k1 --》错了

set k2 v2

exec

第一个错了不影响后面正确的提交

但是

getsteu k1  -》这个错误比较严重

set k1 v2

第一个错了就影响后面正确的提交了