redis缓存数据库简单使用

Redis

1、在Linux上安装与配置

版本

-最新：7.0

-最稳定版本:6.x
-讲课：5.x
-企业里：3.x，4.x，5.x 6.x(极少数公司在用)
-windows：3.x，5.x

特性

1 速度快：10w ops（每秒10w读写），数据存在内存中，c语言实现
2 持久化：rdb和aof
3 多种数据结构：
5大数据结构
BitMaps位图：布隆过滤器 本质是 字符串
HyperLogLog：超小内存唯一值计数，12kb HyperLogLog 本质是 字符串
GEO：地理信息定位 本质是有序集合--》附近5公里的美女
4 支持多种编程语言：基于tcp通信协议，各大编程语言都支持，客户端
5 功能丰富：发布订阅（消息） Lua脚本 事务（pipeline），实现分布式锁---（mysql,redis,zookeeper）
6 简单：源代码几万行，不依赖外部库(源码编译安装---》可执行文件执行)
7 主从复制：主服务器和从服务器，主服务器可以同步到从服务器中
8 高可用和分布式：
2.8版本以后使用redis-sentinel支持高可用
3.0版本以后支持分布式

下载安装与卸载

wget http://download.redis.io/releases/redis-5.0.7.tar.gz
#解压
tar -xzf redis-5.0.7.tar.gz
#建立软连接
ln -s redis-5.0.7 redis
cd redis
# 文件和文件夹
  -Makefile    # make，make install
  -src         # c的源代码
  -redis.conf  # redis的配置文件，启动的时候使用
make && make install
# make:编译---可执行文件
# make install ：安装--》根据config配置---》把可执行文件释放到某个路径，在环境变量中

# 在src目录下可以看到
  #redis-server--->redis服务器
  #redis-cli---》redis命令行客户端
  #redis-benchmark---》redis性能测试工具
  #redis-check-aof--->aof文件修复工具
  #redis-check-dump---》rdb文件检查工具
  #redis-sentinel---》sentinel服务器，哨兵
#redis作者对windows维护不好，window自己有安装包



# 卸载 ---卸载redis
# 1、查看redis进程；
ps aux|grep redis
# 2、kill掉进程；
kill 进程id
# 3、进入到redis目录
cd /root/s20
# 4、删除redis对应的文件
rm -f /usr/local/redis/bin/redis*
rm -f /usr/local/bin/redis*
# 5、删除对应的文件
rm -rf redis

三种启动方式

# 只要在环境变量的某个路径下，在任意位置敲，都能找到
	# 默认的 /usr/bin   /usr/local/bin
  # 系统环境变量，用户环境变

#最简启动,来到redis路径下
./src/redis-server
ps -ef|grep redis  #查看进程
netstat -antpl|grep redis #查看端口
redis-cli -h ip -p port ping #命令查看
redis-cli -h 127.0.0.1 -p 6379


#  动态参数启动
redis-serve --port 6380 #启动，监听6380端口



# 常用：配置文件启动---》100来对配置文件
# redis 的目录下
vim redis.conf

daemonize yes
pidfile /var/run/redis.pid
port 6379
dir "/root/s20/redis/data"
logfile 6379.log

# 启动
mkdir data
redis-server ./redis.conf

客户端连接与客户端查看配置信息

# 无密码情况
redis-cli -p 端口  -h 地址
# 有密码情况
redis-cli -h 127.0.0.1    -p 6370 -a 123456

# 查看redis的配置信息
config get port
config get *   # 100多对

# 修改配置文件---》有漏洞--》可以利用这个漏洞，提权，以root用户登录到你的redis服务器上
CONFIG SET maxmemory 128M  # 设置最大使用的内存
CONFIG set requirepass 123456  # 设置密码,如果没执行下面，在内存中，只要redis服务不重启，就一直生效，但是咱们下写到配置文件中
CONFIG REWRITE  # 保存到配置文件,重启redis，密码也在

# 进入到链接后，再输密码
redis-cli -p 端口  -h 地址
auth 123456
# 登陆的同时输入密码
redis-cli -h 127.0.0.1    -p 6370 -a 123456

redis使用场景

• 缓存系统：使用最广泛的就是缓存,做缓存，接口缓存
• 计数器：网站访问量，转发量，评论数（文章转发，商品销量，不会出现并发问题）
• 消息队列：发布订阅，阻塞队列实现（简单的分布式，blpop：阻塞队列，生产者消费者）
• 排行榜：有序集合（阅读排行，点赞排行，推荐（销量高的，推荐）） 有序集合
• 社交网络：很多特效跟社交网络匹配，粉丝数，关注数 集合
• 实时系统：垃圾邮件处理系统，布隆过滤器

Redis的api使用

通用命令

# 衡量算法好坏的指标，大 O 表示法
	-空间复杂度(占多大内存)，时间复杂(耗费多长时间)
	-O(1),O(log n)，O(n),O(n方)

####1-keys 
#打印出所有key
keys * 
#打印出所有以he开头的key
keys he*
#打印出所有以he开头，第三个字母是h到l的范围
keys he[h-l]
#三位长度，以he开头，？表示任意一位
keys he？
#keys命令一般不在生产环境中使用，生产环境key很多，时间复杂度为o(n),用scan命令

####2-dbsize   计算key的总数
dbsize #redis内置了计数器，插入删除值该计数器会更改，所以可以在生产环境使用，时间复杂度是o(1)

###3-exists key 时间复杂度o(1)
#设置a
set a b
#查看a是否存在
exists a
(integer) 1
#存在返回1 不存在返回0
###4-del key  时间复杂度o(1)
删除成功返回1，key不存在返回0
###5-expire key seconds  时间复杂度o(1)
expire name 3 #3s 过期
ttl name  #查看name还有多长时间过期
persist name #去掉name的过期时间
###6-type key  时间复杂度o(1)
type name #查看name类型，返回string


### 7 其他-->系统相关
info命令：内存，cpu，主从相关，django写一个redis服务监控，折线图，饼形图
	使用subprocess模块，redis-cli -a 123456 info 返回字符串命令结果，做初步处理成字典
client list  正在连接的会话
client kill ip:端口
# client kill 127.0.0.1:40704
dbsize  总共有多少个key
flushall  清空所有
flushdb  只清空当前库  # 16 个库
select 数字  选择某个库  总共16个库  # 默认在第0个
monitor  记录操作日志，夯住

一次只会执行一条命令

快：

1、纯的内存访问、数据放在内存中

2、非阻塞I/O，Redis采用epoll做为I/O多路复用技术的实现，自身实现了事件处理，不在网络io上浪费过多时间

注意：

1、一次只会执行一次命令

2、拒绝长慢命令

​ -keys，flushall,flushdb,慢的lua脚本，mutil/exec，operate，big value

3、其实不是单线程（在做持久化是另外的线程）

在做后台持久化的时候会另外fork出来一个线程去做

字符串操作命令

###1---基本使用get，set，del
get name       #时间复杂度 o(1)
set name lqz   #时间复杂度 o(1)
del name       #时间复杂度 o(1)
###2---其他使用incr,decr,incrby,decrby
incr age  #对age这个key的value值自增1
decr age  #对age这个key的value值自减1
incrby age 10  #对age这个key的value值增加10
decrby age 10  #对age这个key的value值减10
#统计网站访问量（单线程无竞争，天然适合做计数器）
#缓存mysql的信息（json格式）


###3---set，setnx，setxx
set name lqz  #不管key是否存在，都设置 
setnx name lqz #key不存在时才设置（新增操作）
set name lqz nx #同上
set name lqz xx #key存在，才设置（更新操作）

###4---mget mset
mget key1 key2 key3     #批量获取key1，key2.。。时间复杂度o(n)
mset key1 value1 key2 value2 key3 value3    #批量设置时间复杂度o(n)

# n次get和mget的区别   n次get时间=n次命令时间+n次网络时间  mget时间=1次网络时间+n次命令时间

###5---其他：getset，append，strlen
getset name lqznb #设置新值并返回旧值 时间复杂度o(1)
append name 666 #将value追加到旧的value 时间复杂度o(1)
strlen name  #计算字符串长度,字节(注意中文，3个字节)  时间复杂度o(1)

###6---其他：incrybyfloat,getrange,setrange
increbyfloat age 3.5  #为age自增3.5，传负值表示自减 时间复杂度o(1)
getrange key start end #获取字符串制定下标所有的值  时间复杂度o(1)
setrange key index value #从指定index开始设置value值  时间复杂度o(1)

哈希类型操作命令

注意：value值只支持一层，不能套其它列表、集合之类的数据
info  {name:lqz,age:19,hobby:字符串}

###1---hget,hset,hdel
hget key field  #获取hash key对应的field的value 时间复杂度为 o(1)
hset key field value #设置hash key对应的field的value值 时间复杂度为 o(1)
hdel key field #删除hash key对应的field的值 时间复杂度为 o(1)
#测试
hset user:1:info age 23
hget user:1:info ag
hset user:1:info name lqz
hgetall user:1:info
hdel user:1:info age
###2---hexists,hlen
hexists key field  #判断hash key 是否存在field 时间复杂度为 o(1)
hlen key   #获取hash key field的数量  时间复杂度为 o(1)
hexists user:1:info name
hlen user:1:info  #返回数量
        
###3---hmget，hmset
hmget key field1 field2 ...fieldN  #批量获取hash key 的一批field对应的值  时间复杂度是o(n)
hmset key field1 value1 field2 value2  #批量设置hash key的一批field value 时间复杂度是o(n)

###4--hgetall,hvals，hkeys
hgetall key  #返回hash key 对应的所有field和value  时间复杂度是o(n)
hvals key   #返回hash key 对应的所有field的value  时间复杂度是o(n)
hkeys key   #返回hash key对应的所有field  时间复杂度是o(n)

###小心使用hgetall
##1 计算网站每个用户主页的访问量
hincrby user:1:info pageview count
    
##2 缓存mysql的信息，直接设置hash格式-->建议用字符串，json形式存



##其他操作 hsetnx，hincrby，hincrbyfloat
hsetnx key field value #设置hash key对应field的value（如果field已存在，则失败），时间复杂度o(1)
hincrby key field intCounter #hash key 对英的field的value自增intCounter 时间复杂度o(1)
hincrbyfloat key field floatCounter #hincrby 浮点数 时间复杂度o(1)

列表操作命令

# 有序队列，可以从左侧添加，右侧添加，可以重复，可以从左右两边弹出

# 插入操作
#rpush 从右侧插入
rpush key value1 value2 ...valueN  #时间复杂度为o(1~n)
#lpush 从左侧插入
#linsert
linsert key before|after value newValue   #从元素value的前或后插入newValue 时间复杂度o(n) ，需要遍历列表
linsert listkey before b java
linsert listkey after b php

# 删除操作
lpop key #从列表左侧弹出一个item 时间复杂度o(1)
rpop key #从列表右侧弹出一个item 时间复杂度o(1)
lrem key count value
#根据count值，从列表中删除所有value相同的项 时间复杂度o(n)
1 count>0 从左到右，删除最多count个value相等的项
2 count<0 从右向左，删除最多 Math.abs(count)个value相等的项
3 count=0 删除所有value相等的项
lrem listkey 0 a #删除列表中所有值a
lrem listkey -1 c #从右侧删除1个c
ltrim key start end #按照索引范围修剪列表 o(n)
ltrim listkey 1 4 #只保留下表1--4的元素

# 查询
lrange key start end #包含end获取列表指定索引范围所有item  o(n)
lrange listkey 0 2
lrange listkey 1 -1 #获取第一个位置到倒数第一个位置的元素

lindex key index #获取列表指定索引的item  o(n)
lindex listkey 0
lindex listkey -1

llen key #获取列表长度

# 修改
lset key index newValue #设置列表指定索引值为newValue o(n)
lset listkey 2 ppp #把第二个位置设为ppp

# 其它
blpop key timeout #lpop的阻塞版，timeout是阻塞超时时间，timeout=0为拥有不阻塞 o(1)
brpop key timeout #rpop的阻塞版，timeout是阻塞超时时间，timeout=0为拥有不阻塞 o(1)

#要实现栈的功能：先进后出，后进先出---》吃了吐
lpush+lpop   
#实现队列功能：先进先出---》吃了拉--》直梯
lpush+rpop 
#固定大小的列表
lpush+ltrim   
#消息队列
lpush+brpop 

集合

sadd key element #向集合key添加element（如果element存在，添加失败） o(1)

srem key element #从集合中的element移除掉 o(1)

scard key #计算集合大小

sismember key element #判断element是否在集合中  

srandmember key count #从集合中随机取出count个元素，不会破坏集合中的元素 (抽奖)


spop key #从集合中随机弹出一个元素

smembers key #获取集合中所有元素 ，无序，小心使用，会阻塞住 

sdiff user:1:follow user:2:follow  #计算user:1:follow和user:2:follow的差集

sinter user:1:follow user:2:follow  #计算user:1:follow和user:2:follow的交集
          
sunion user:1:follow user:2:follow  #计算user:1:follow和user:2:follow的并集
                
sdiff|sinter|suion + store destkey... #将差集，交集，并集结果保存在destkey集合中

应用：

1、抽奖系统：通过spop来弹出用户的id，活动取消，直接删除

2、点赞，点踩，喜欢等，用户如果点了赞，就把用户id放到该条记录的集合中

3、标签：给用户/文章等添加标签，sadd user:1:tags 标签1 标签2 标签3

4、给标签添加用户，关注该标签的人有哪些

5、共同好友：集合间的操作

有序集合

zadd key score element #score可以重复，可以多个同时添加，element不能重复 o(logN) 

zrem key element #删除元素，可以多个同时删除 o(1)

zscore key element #获取元素的分数 o(1)

zincrby key increScore element #增加或减少元素的分数  o(1)

zcard key #返回元素总个数 o(1)

zrank key element #返回element元素的排名（从小到大排,从0开始）

zrange key 0 -1 #返回排名，不带分数  o(log(n)+m) n是元素个数，m是要获取的值
zrange player:rank 0 -1 withscores #返回排名，带分数

zrangebyscore key minScore maxScore #返回指定分数范围内的升序元素 o(log(n)+m) n是元素个数，m是要获取的值
zrangebyscore user:1:ranking 90 210 withscores #获取90分到210分的元素

zcount key minScore maxScore #返回有序集合内在指定分数范围内的个数 o(log(n)+m)

zremrangebyrank key start end #删除指定排名内的升序元素 o(log(n)+m)
zremrangebyrank user:1:rangking 1 2 #删除升序排名中1到2的元素

zremrangebyscore key minScore maxScore #删除指定分数内的升序元素 o(log(n)+m)
zremrangebyscore user:1:ranking 90 210 #删除分数90到210之间的元素


zrevrank #从高到低排序
zrevrange #从高到低排序取一定范围
zrevrangebyscore #返回指定分数范围内的降序元素
zinterstore #对两个有序集合交集
zunionstore #对两个有序集合求并集
# 排行榜---》金币排行，阅读排序，销量排行

应用：

排行榜：金币排行，阅读排序，销量排行

客户端操作

python 用 redis模块模块操作redis

go： https://www.cnblogs.com/liuqingzheng/p/16024070.html

高级用法值慢查询

# 通过配置，对慢查询命令的保存，通过命令，取出保存的慢查询命令---》分析
# 两个配置
慢查询是一个先进先出的队列
固定长度
保存在内存中
slowlog-max-len=128 
slowly-log-slower-than=10000  # 毫秒，超过这个毫秒的，就会被记录在队列中


# 配置
config set slowlog-log-slower-than 0
config set slowlog-max-len 100
config rewrite


# 命令
slowlog get [n]  # 查到哪个用户执行的那个命令
slowlog len    #获取慢查询队列长度
slowlog reset #清空慢查询队列

pipline事务

# Redis的pipeline(管道)功能在命令行中没有，但redis是支持pipeline的，而且在各个语言版的client中都有相应的实现（客户端又，py-redis，go-redis）

# 将一批命令，批量打包，在redis服务端批量计算(执行)，然后把结果批量返回

# 1次pipeline(n条命令)=1次网络时间+n次命令时间

# pipeline期间将“独占”链接，此期间将不能进行非“管道”类型的其他操作，直到pipeline关闭；如果你的pipeline的指令集很庞大，为了不干扰链接中的其他操作，你可以为pipeline操作新建Client链接，让pipeline和其他正常操作分离在2个client中。不过pipeline事实上所能容忍的操作个数，和socket-output缓冲区大小/返回结果的数据尺寸都有很大的关系；同时也意味着每个redis-server同时所能支撑的pipeline链接的个数，也是有限的，这将受限于server的物理内存或网络接口的缓冲能力

import redis
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
# pipe = r.pipeline(transaction=False)
#创建pipeline
pipe = r.pipeline(transaction=True)
#开启事务
pipe.multi()
pipe.set('name', 'lqz')
#其他代码，可能出异常
pipe.set('role', 'nb')

pipe.execute()

#### #注意：pipeline每次只能作用在一个Redis的节点上  集群环境中，用不了pipline


# # redis支持事务操作
# 1 mutil  开启事务，放到管道中一次性执行--->管道的使用

multi   # 开启事务
set name lqz
set age 18
exec


# 2 模拟事务
# 在开启事务之前，先watch,监控age，如果被别人改了，它就改不成功了--》乐观锁
wathc age
multi
decr age
exec

# 另一台机器
multi
decr age
exec  # 先执行，上面的执行就会失败(乐观锁，被wathc的事务不会执行成功)


# 集成到项目中---demo
https://www.cnblogs.com/liuqingzheng/p/9997092.html

发布订阅

# 发布者发布了消息，所有的订阅者都可以收到，就是生产者消费者模型升级（后订阅了，无法获取历史消息）---》观察者模式
# redis支持，不仅仅用redis可以实现---》消息队列：rabbimq都支持发布订阅


# 其中一个客户端发布消息
publish lmx:channel "hello world" 
# 其他客户端订阅消息 
subscribe lmx:channel   # 一个客户端可以收听多个频道
  
# 只要客户端在这个频道发消息，所有订阅的都能收到
publish lmx:channel "hello world" 
  
  
  
# 发布订阅和消息队列
	消息队列---》多个客户端抢，谁抢到是谁的
  发布订阅---》多个客户端都能收到
  
	基本所有的专业的消息队列都支持发布订阅---》往消息队列中放一条消息，其实是消息队列这个软件负责把消息复制了多份，分别放到了订阅者订阅的队列中

bitmap位图

# 本质就是字符串类型
# 存到redis中，字符串会对应相应的二进制---》可以操作字符串的每个比特位
# 假设放了个big----》


set name big  
getbit name 0  # 取到某个位置比特位

setbit name 7 1  # 把第7个位置设为1

bitcount name 0 3  #取出起始位置到终止位置1的个数， 起始位置和终止位置指的是字节数


# 作用：独立用户统计---》统计日活
-用户id号，一般是自增数字----》假设10亿的用户量
-统计日活跃用户---》只要用户登录了就把用户id放到集合中，统计集合大小即可--》大数据量非常占空间
	-go中：int8----》能表示数字范围 8个比特位 能表示数字范围：2的7次方-1
  			int类型---》int32----》2的31次方-1
    
-假设活跃用户5千万： 
	-使用集合：32位*5千万=200MB
  -使用bitmap：1位*1亿=12.5MB  # 只要登陆了，相应数字的位置设为1，没登陆是0
    		
    
    
# 注意：
1 位图类型是string类型，最大512M   # redis key和value类型最大能存多少？512m
2 使用setbit时偏移量如果过大，会有较大消耗
3 位图不是绝对好用，需要合理使用

HyperLogLog

# 基于HyperLogLog算法：极小的空间完成独立数量统计---->本质还是字符串


pfadd key element   #向hyperloglog添加元素,可以同时添加多个,自带去重
pfcount key         #计算hyperloglog的独立总数
pfmerge destroy sourcekey1 sourcekey2  # 把sourcekey1和sourcekey2的内容合并到destroy中

# 带去重，为什么不用集合？
	-HyperLogLog只能放，不能取，只能做统计，和去重，占得空间比set小的都得多
  -百万级别独立用户统计，百万条数据只占15k
	-错误率 0.81%
	-无法取出单条数据，只能统计个数	
  
  
# 用户的主键id，可能不是数字，是uuid，唯一的字符串，如果用bitmap就做不了，就可以使用HyperLogLog

# 在能忍受有误差的情况下，使用HyperLogLog做独立用户统计或去重

布隆过滤器

bloomfilter：是一个通过多哈希函数映射到一张表的数据结构，能够快速的判断一个元素在一个集合内是否存在，具有很好的空间和时间效率


# from pybloom_live import ScalableBloomFilter
# bloom = ScalableBloomFilter(initial_capacity=100, error_rate=0.001, mode=ScalableBloomFilter.LARGE_SET_GROWTH)
#
# url = "www.cnblogs.com"
#
# url2 = "www.liuqingzheng.top"
#
# bloom.add(url)
#
# print(url in bloom)
#
# print(url2 in bloom)




# BloomFilter 是定长的
from pybloom_live import BloomFilter
bf = BloomFilter(capacity=1000)
url='www.baidu.com'
bf.add(url)

print(url in bf)

print("www.liuqingzheng.top" in bf)

redis实现布隆过滤器：

redis实现布隆过滤器--》布隆不是官方的---》第三方使用c开发了---》编译---》so,dll文件动态链接库

把所有代码都打包到 xx.exe--->200m非常大---》go只能这样
动态链接(python 的包)---》可执行文件只有1kb---》从硬盘加载内存---》先占1kb内存--》运行---》动态加载dll，so文件----》完成后续的功能
win下是dll，linux是so文件---》C语言写的编译过后的动态链接库

redis已经编译完成了---》挂载 布隆过滤器---》编译成so，redis启动时加载进去就行了4



go 语言代码编译成动态链接库，python调用
https://zhuanlan.zhihu.com/p/355538331
  
  
第三方提供了一些动态链接库，让我们使用---》华为硬件设备(摄像头)
xx.so文件，说明文本(函数作用，参数)---》python写代码控制摄像头
xx.so 内用c语言已经写好了，比如有个openVideo方法
from ctypes import cdll
lib = cdll.LoadLibrary('./s1.so')
lib.openVideo()  # 打开了摄像头

GEO地理位置信息

# 地理位置信息：GEO（地理信息定位）：存储经纬度，计算两地距离，范围等，计算你跟xx店之间距离是多少，计算你方圆5公里内有多少你关注美女----》直线距离，不是路线距离

# 增加数据
geoadd redis的key 经度 纬度 名字
geoadd cities:locations 116.28 39.55 beijing
geoadd cities:locations 117.12 39.08 tianjin
geoadd cities:locations 114.29 38.02 shijiazhuang
geoadd cities:locations 118.01 39.38 tangshan
geoadd cities:locations 115.29 38.51 baoding
  
# 软件，app，经纬度，都是前端传给你的，app申请访问你的位置信息--》后台偷偷用借口传入到服务器---》存到redis中

# 获取经纬度
geopos cities:locations beijing   # 取出是经纬度---》把经纬度转成具体位置
  
# 计算两个位置的距离
geodist cities:locations beijing tianjin km
  
# 计算某个位置方圆 100km内有哪些---》包括自己---》
georadiusbymember cities:locations beijing 100 km

持久化rdb

# redis的所有数据保存在内存中，对数据的更新将异步的保存到硬盘上

# 三种方案：rdb，aof，混合持久化(rdb+aof)-->恢复更快


# 无论什么数据库，都会有相应的持久化方案
  快照：某时某刻数据的一个完成备份
    -mysql的Dump
    -redis的RDB
  写日志：任何操作记录日志，要恢复数据，只要把日志重新走一遍即可
    -mysql的 Binlog
    -Redis的 AOF




# rdb 三种触发形式
	-第一种：客户端命令敲---》   save   ---》同步，阻塞当前线程，把当前内存中数据保存到硬盘上
  	-redis的工作路径下会多出dump.rdb
    -下次再启动会自动加载
  -第二种：客户端命令敲---》   bgsave ---》异步保存---》
  -第三种：配置文件
  	'''
    自动（通过配置）
    配置   seconds   changes
    save   900        1
    save   300        10
    save   60         10000
    如果60s中改变了1w条数据，自动生成rdb
    如果300s中改变了10条数据，自动生成rdb
    如果900s中改变了1条数据，自动生成rdb
    以上三条符合任意一条，就自动生成rdb，内部使用bgsave
    '''

    save 60 2
    dbfilename lqz.rdb 


# rdb方案可能会丢数据，但是如果redis只作为缓存数据库，这个就够了

持久化aof

# 日志方案---》每更改一条记录，都会记录一条日志
# 操作内存，速度非常快，记录日志---》日志要同步到硬盘---》跟不上节奏

# AOF的三种策略
always：redis–》写命令刷新的缓冲区—》每条命令fsync到硬盘—》AOF文件  # 基本跟不上
everysec（默认值）：redis——》写命令刷新的缓冲区—》每秒把缓冲区fsync到硬盘–》AOF文件
no:redis——》写命令刷新的缓冲区—》操作系统决定，缓冲区fsync到硬盘–》AOF文件
  
# AOF 重写
随着命令的逐步写入，并发量的变大， AOF文件会越来越大，通过AOF重写来解决该问题
本质就是把过期的，无用的，重复的，可以优化的命令，来优化
这样可以减少磁盘占用量，加速恢复速度

# 如何实现aof重写---》配置文件--》触发了配置条件，就会开启线程进行重写
appendonly yes #将该选项设置为yes，打开aof持久化策略
appendfilename appendonly.aof   #文件保存的名字，aof日志的文件名，不写有默认
appendfsync everysec #采用第二种策略
no-appendfsync-on-rewrite yes #在aof重写的时候，是否要做aof的append操作，因为aof重写消耗性能，磁盘消耗，正常aof写磁盘有一定的冲突，这段期间的数据，允许丢失
auto-aof-rewrite-min-size = 10  # AOF文件重写需要尺寸
auto-aof-rewrite-percentage= 2  # 文件增长率


# 咱们配置

appendonly yes
appendfilename appendonly.aof
appendfsync everysec
no-appendfsync-on-rewrite yes 




# 混合持久化---》恢复速度问题
重启Redis时，我们很少使用rdb来恢复内存状态，因为会丢失大量数据。我们通常使用AOF日志重写，
AOF重写性能相对rdb来说要慢很多
Redis 4.0 为了解决这个问题，带来了一个新的持久化选项——混合持久化
重启，恢复的时候，使用rdb恢复，有差距的再用aof补上


# 配置---》记日志---》过一段时间---》把aof重写，rdb+日志
# aof一重写：rdb文件路径  + 后续的aof


aof-use-rdb-preamble yes

主从复制

# 单实例redis出现问题：
  机器故障----》
  容量瓶颈 ----》100g数据 内存64g，
  QPS瓶颈----》
  
  
# 主从原理
一主一从，一主多从
做读写分离---》写数据写到主库---》读数据从从库读---》压力就小了
做数据副本---》从库和主库数据是完全一样的，主库被火烧了-->从库还有数据


一个maskter可以有多个slave
一个slave只能有一个master
数据流向是单向的，从master到slave  # 从库不能在写入数据了


# reids主从原理
1. 副本库通过slaveof 127.0.0.1 6379命令,连接主库,并发送SYNC给主库 
2. 主库收到SYNC,会立即触发BGSAVE,后台保存RDB,发送给副本库
3. 副本库接收后会应用RDB快照
4. 主库会陆续将中间产生的新的操作,保存并发送给副本库
5. 到此,我们主复制集就正常工作了
6. 再此以后,主库只要发生新的操作,都会以命令传播的形式自动发送给副本库.
7. 所有复制相关信息,从info信息中都可以查到.即使重启任何节点,他的主从关系依然都在.
8. 如果发生主从关系断开时,从库数据没有任何损坏,在下次重连之后,从库发送PSYNC给主库
9. 主库只会将从库缺失部分的数据同步给从库应用,达到快速恢复主从的目的


# 要不要开启持久化---》一般开启持久化
如果不开有可能，主库重启操作，造成所有主从数据丢失！


# 主从辅助配置
min-slaves-to-write 1
min-slaves-max-lag 3
# 那么在从服务器的数量少于1个，或者三个从服务器的延迟（lag）值都大于或等于3秒时，主服务器将拒绝执行写命令



# 主从同步配置---》一台机器起两个redis进程模拟，正常应该有多台机器
# 方式一：命令方式
slaveof 127.0.0.1 6379 #异步
slaveof no one #取消复制，不会把之前的数据清除


# 方式二：配置文件

# 在从库配置
slaveof 127.0.0.1 6379
slave-read-only yes



# 一主多从
	只需要在从库配置上面两句就可以了