文章目录
1.为什么要使用缓存
-
缓解关系数据库并发访问的压力:热点数据
-
减少响应时间:内存IO速度比磁盘快(从数据库中读取数据一般十几毫秒,从内存中读取数据一般十几微妙)
-
提升吞吐量:Redis等内存数据库单机就可以支撑很大的并发
2.常见的内存缓存工具有Redis和Memcached
3.简述Redis常用数据类型和使用场景
数据类型 | 应用场景 |
---|---|
String(字符串) | 计数器,分布式锁 |
List(链表) | 消息队列,任务队列 |
Hash(Hash表) | 用户信息 |
Set(集合) | 去重 |
ZSet(有序集合) | 排行榜 |
4.Redis内置实现
类型 | c底层实现 |
---|---|
String | int或者sds(simple dynamic string) |
List | ziplist或者double linked list双向链表功能 |
Hash | ziplist或者hashtable |
Set | intset或者hahstable |
SortedSet | skiplist跳跃表 |
注意
1.这些数据结构操作的时间和空间复杂度是多少,深入学习参考 <<Redis设计与实现>>
5.Redis持久化方式
持久化方式 | 定义 |
---|---|
RDB(Redis Database Backup file) | 将内存数据保存到磁盘的二进制文件dump.rdb中( 主从复制就是基于RDB持久化功能实现),速度更快,一般用作备份,也称之为基于快照的持久化 |
AOF(append Only File) | 每一个写命令追加到appendonly.aof中,可以最大程度的保证redis数据安全,类似于mysql的binlog |
-
RDB
dir /data/6379 #定义持久化文件存储位置 dbfilename dbmp.rdb #rdb持久化文件
-
AOF
appendonly yes appendfsync always 总是修改类的操作 everysec 每秒做一次持久化 no 依赖于系统自带的缓存大小机制
6.Redis事务
- 将多个请求打包,一次性,按序执行多个命令的机制
- redis通过multi,exec,watch等命令实现事务功能
- redis-py
pipline=conn.pipeline(transaction=True)
7.redis如何实现分布式锁
背景:分布式系统在共享资源时为保证数据的一致性
- 使用setnx(key,value,expire)实现加锁(互斥锁)
- 锁的value值可以使用一个随机的uuid或者特定的命名
- 释放锁的时候,通过uuid判断是否是该锁,是则执行delete释放锁
支持超时时间参数
import uuid
import math
import time
def acquire_lock_with_timeout(conn, lock_name, acquire_timeout=3, lock_timeout=2):
"""
基于 Redis 实现的分布式锁
:param conn: Redis 连接
:param lock_name: 锁的名称
:param acquire_timeout: 获取锁的超时时间,默认 3 秒
:param lock_timeout: 锁的超时时间,默认 2 秒
:return:
"""
identifier = str(uuid.uuid4())
lockname = f'lock:{lock_name}'
lock_timeout = int(math.ceil(lock_timeout))
end = time.time() + acquire_timeout
while time.time() < end:
# 如果不存在这个锁则加锁并设置过期时间,避免死锁
if conn.set(lockname, identifier, ex=lock_timeout, nx=True):
return identifier
time.sleep(0.001)
return False
def release_lock(conn, lock_name, identifier):
"""
释放锁
:param conn: Redis 连接
:param lockname: 锁的名称
:param identifier: 锁的标识
:return:
"""
unlock_script = """
if redis.call("get",KEYS[1]) == ARGV[1] then
return redis.call("del",KEYS[1])
else
return 0
end
"""
lockname = f'lock:{lock_name}'
unlock = conn.register_script(unlock_script)
result = unlock(keys=[lockname], args=[identifier])
if result:
return True
else:
return False
深入思考:如果Redis单个节点宕机,如何处理?还有其他业界的方案实现分布锁吗
参考:
8.常用的缓存读写策略
-
旁路缓存模式(Cache Aside)
-
读
- 从
cache
中读取数据,读取到就直接返回 cache
中读取不到的话,就从DB
读取返回- 再把数据写到
cache
中
- 从
-
写
- 先更新
DB
。 - 然后直接删除
cache
- 先更新
-
缺点
- 首次请求的数据一定不在cache的问题
- 写操作比较频繁的话导致cache中的数据会被频繁的删除
-
思考
- 如果在写数据的过程中,可以先删除cache,再更新DB吗
- 如果先写BD,再删除cache就不会造成数据不一致了吗
-
-
读写穿透(Read/Write Through)
-
读:
- 先从
cache
中读取数据,读取到直接返回。 - 从
cache
中读取不到,则先从DB
加载写入到cache
后返回响应。
- 先从
-
写
- 先查
cache
,cache
中不存在,直接更新DB
。 cache
中存在,则先更新cache
,然后cache
服务自己更新DB
(同时更新DB
和cache
)
- 先查
-
-
异步缓存写入(Write Behind Pattern)
-
读:
- 先从
cache
中读取数据,读取到直接返回。 - 从
cache
中读取不到,则先从DB
加载写入到cache
后返回响应。
- 先从
-
写
- 先查
cache
,cache
中不存在,不直接更新 db,而是改为异步批量的方式来更新 db cache
中存在,则先更新cache
,不直接更新 db,而是改为异步批量的方式来更新 db
- 先查
-
9.如何解决Redis缓存穿透问题
描述大量要访问的数据既不在Redis 缓存中,也不在数据库
**原因:**缓存和数据库中都没有要访问的数据
解决方案
- 对于没查到返回为None的数据也缓存或者设置缺省
- 对入口请求合法性检查
- 布隆过滤器
- 插入数据的时候删除相应缓存,或者设置较短的超时时间
10.如何解决Redis缓存击穿
描述: 某个访问非常频繁的热点数据,缓存中没有数据,访问该数据的大量请求,一下子都发送到数据库,导致数据库压力激增
原因: 热点数据过期失效
解决方案:
- 不给热点数据加过期时间
- 分布式锁:获取锁的线程从数据库拉数据更新缓存,其他线程等待
- 异步后台更新:后台任务针对过期的key自动刷新
11.如何解决缓存雪崩问题
- 描述:缓存中有大量的数据同时过期导致在Redis缓存无法处理,应用将大量请求发送到数据库层,导致数据库层的压力激增
- 原因:
- 缓存中有大量数据同时过期,导致大量请求数据库
- 实例宕机
- 解决方案:
- 多节缓存:不同级别的key设置不同的超时时间
- key的超时时间随机设置,防止同时超时
- 架构层:提升系统可用性.监控,报警完善
12.实现发布/订阅
订阅者
import time
from redis import StrictRedis
s = StrictRedis(host='', port=6379, password='')
sub = s.pubsub()
sub.subscribe('FM101', 'FM102')
sub.subscribe('*ython1', '2python*') # 通配符不生效
while True:
time.sleep(1)
msg = sub.parse_response()
print("msg:%s" % msg)
发布者
from redis import StrictRedis
r = StrictRedis(host='', port=6379, password='')
res1 = r.publish('FM101', 'hello 1')
res2 = r.publish('FM102', 'hello 2')
res3 = r.publish('python1', 'python1')
res4 = r.publish('2python2', 'python2')
print(res1) # 返回订阅者数量
print(res2) # 返回订阅者数量
print(res3) # 返回订阅者数量
print(res4) # 返回订阅者数量
13.Redis的python基本操作
from redis import StrictRedis
r = StrictRedis(host='', port=6379, password='')
r.ping() # 运行测试命令
r.select(1) # 切换数据库
# 1.String
# mset,mget
r.set('age', 23, ex=100, nx=True)
r.get('age')
# mset,mget
r.mset({'k3': 'v3', 'k4': 'v4'})
r.mget('k1', 'k2', 'k3') # [None, None, b'v3']
# append
r.get('age') # b'17'
a = r.append('age', 6) # b'176'
a.decode('utf-8') # '176
# 2.keys
# key
r.keys() # [b'age', b'k4', b'k3']
r.keys('k*') # 查看包含k的键
# exists
r.exists('age') # 1:表示存在 0表示不存在
# type
r.type('age') # b'string'
# delete
r.delete('k3', 'k4') # 正数:表示删除的数量 0表示不存在
# expire
r.expire('k3', 6) # 将k3这个键设置为6秒过期
# getrange
r.get('k4') # b'v4'
r.getrange('k4', 0, 1) # b'4'
# key
r.ttl('k4') # 查看键k4的有效时间
# 3.hash
r.hset('person', 'name', 'jason')
r.hset('person', 'age', 18)
r.hget('person', 'age')
r.hgetall('person')
r.hvals('person')
r.hmset('person3', {'name3': 'jason', 'age3': 16})
r.delete('person1')
r.hdel('person3', 'name3')
# 4.list
r.lpush('a1', 'a', 'b', 'c') # 在左侧插⼊数据
r.rpush('a1', 0, 1) # 在右侧插⼊数据
r.lrange('a1', 0, -1)
r.lset('a1', 0, 'z')
r.lrem('a1', -2, 'b') # 从a1列表右侧开始删除2个b
# set:集合没有修改操作
r.sadd('name', 'jason1', 'jason2')
r.smembers('name')
r.srem('name', 'json1')
r.srem('name')
# zset:有序集合没有修改操作,通过权重将元素从⼩到⼤排序
r.zadd('name2', {'jason1': 4, 'jason2': 5})
r.zrange('name2', 0, -1)
r.zrangebyscore('name2', 4, 5)
r.zscore('name2', 'jason1')
r.zremrangebyscore('name2', 4, 5)
# 管道
pipe = r.pipeline()
pipe.set('a1', '11')
pipe.set('a2', '12')
pipe.execute()
pipe.watch() # 如果在事务执行之前这个(或这些) key 被其他命令所改动,那么事务将被打断
pipe.multi() # 标记一个事务块的开始