Redis 缓存与分布式
# NoSQL KV 数据库
主要的三个使用场景
- 数据缓存
- 分布式锁
- 消息队列(简单的发布-订阅场景)
# 古法安装
上传安装包放在服务器 /opt 目录下并解压
mv redis-6.2.6.tar.gz /opt
tar -zxvf redis-6.2.6.tar.gz
2
进入 redis 目录编译下载
cd redis-6.2.6.tar.gz
yay -S make
yay -S pkg-config
make && make install
2
3
4
5
6
默认安装路径
/usr/local/bin
进入该目录,将redis.conf拷贝至当前目录,使用这个拷贝的文件进行配置启动
mkdir config
cp /home/northboat/redis-6.2.6/redis.conf config
2
修改默认启动方式
cd config
vim redis.conf
#设置 daemonize 为 yes 保存并退出
2
3
在 /usr/local/bin 目录下启动服务,通过指定的配置文件启动
redis-server config/redis.conf
数据库操作与命名:连接 redis
redis-cli -p 6379 # -h 默认为本机
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> set name NorthBoat
OK
127.0.0.1:6379> get name
"NorthBoat"
127.0.0.1:6379> get a
(nil)
127.0.0.1:6379> keys *
1) "name"
2
3
4
5
6
7
8
9
10
11
12
查看 redis 进程是否开启
ps -ef|grep redis
#查看后台java进程
ps -ef|grep java
jps -l -v
2
3
4
5
关闭 redis 服务
127.0.0.1:6379> shutdown
not connected> exit
2
设置密码,在 redis.conf 中搜索 requirepass,插入新行
# vim搜索:":/requirepass",按寻找下一个
requirepass 123456
2
在登录 redis 后验证密码即可操作数据
auth "123456"
#或在启动时验证,这样并不安全,因为密码可见
redis-cli -p 6379 -a 123456
2
3
4
可视化工具:Another Redis Desktop Manager (opens new window)
# 数据类型
键规范:业界规范即采用冒号作为分隔符表示数据的层级关系,一套常用的结构模板
| 类型 | 命名规则 | 示例 |
|---|---|---|
| 用户 Token 存储 | login:token:{token} | login:token:abc123 |
| 用户 ID 映射 Token | login:user:{userId} | login:user:u001 |
| 缓存(对象) | cache:{业务}:{标识} | cache:user:u001 |
| 限流 | rate_limit:{类型}:{标识} | rate_limit:ip:127.0.0.1 |
| 队列 | queue:{业务} | queue:email |
| 计数器 | counter:{业务}:{标识} | counter:login_fail:u001 |
| 分布式锁 | lock:{资源} | lock:order:123456 |
| 会话管理 | session:{sessionId} | session:sess_abc123 |
String:从Redis中取出的字符串在Java程序中会显示为"NorthBoat"的形式,要加转义字符\"表示双引号
127.0.0.1:6379> set name NorthBoat
OK
127.0.0.1:6379> get name
"NorthBoat"
# 批量设置
127.0.0.1:6379> mset id 4 grade 11
OK
# 批量获取
127.0.0.1:6379> mget id grade
1) "4"
2) "11"
2
3
4
5
6
7
8
9
10
11
12
List
# 向左插入队列
127.0.0.1:6379> lpush test redis
(integer) 1
127.0.0.1:6379> lpush test mysql
(integer) 2
# 查看队列
127.0.0.1:6379> lrange test 0 10
1) "redis"
2) "mysql"
# 查看队列长度
127.0.0.1:6379> llen test
(integer) 2
# 删除元素
# 1 表示从左向右找第一个元素删
# -1 表示从右向左找第一个元素删
# 0 表示把该元素删完
127.0.0.1:6379> lrem test 1 mysql
(integer) 1
# 从 start 删到 end,若 start > end 则删完
127.0.0.1:6379> ltrim test 1 0
(integer) 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Hash:一个嵌套的哈希表Map<String, Map<String, Object>>
// 获取key表中itme对应的值
public Object hget(String key, String item){
return myRedisTemplate.opsForHash().get(key, item);
}
// 获取整个Hash表
public Map hmget(String key){
return myRedisTemplate.opsForHash().entries(key);
}
// 简单设置一个Hash
public boolean hmset(String key, Map<String, Object> map){
try{
myRedisTemplate.opsForHash().putAll(key, map);
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
// 设置一个Hash,并设置生效时间,调用上面的设置key生效时间的方法
public boolean hmset(String key, Map<String, Object> map, long time){
try{
myRedisTemplate.opsForHash().putAll(key, map);
if(time > 0){
this.expire(key, time);
}
return true;
}catch (Exception e){
return false;
}
}
// 像一张Hash表中添加键值,若表不存在将创建
public boolean hset(String key, String item, Object val){
try{
myRedisTemplate.opsForHash().put(key, item, val);
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
Set:无序集合Map<String, Set<String>>,其实就相当于一个值全为 null 的 Hash(Map<String, Map<String, null>>)
# 添加 sadd
127.0.0.1:6379> sadd test redis
(integer) 1
127.0.0.1:6379> sadd test mysql
(integer) 1
127.0.0.1:6379> sadd test mysql
(integer) 0
# 获取 smembers
127.0.0.1:6379> smembers test
1) "mysql"
2) "redis"
3) "mongodb"
# 判断存在 sismember
127.0.0.1:6379> sismember test mysql
(integer) 1
# 删除 srem
127.0.0.1:6379> srem test mysql
(integer) 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Zset / SortedSet:有序集合,每个元素有一个 double 类型的权重,Zset 将根据权重对元素进行排序Map<String, Map<String, Double>>
- zadd key weight val:添加成员,weight 为权重
- zrange start end:查询下标 start 到 end 的元素
- zrem key member:删除成员
- zcard key:查询数量
特殊数据类型支持
- Geospatial(地理空间):用于存储地理位置信息,支持距离计算、范围查询等功能
- HyperLogLog:用于基数统计(估算集合中不重复元素的数量),内存效率极高,适用于大数据量的去重计数
- Bitmap(位图):基于字符串类型的二进制位操作,适合处理大量状态标记场景
- Json:存储 json string 以承载关系数据的缓存,键用前缀 + MySQL 主键
- 向量存储:可以通过 Redis Vectorset 实现向量存储
# 持久化方法
日志和快照
Redis 有两种持久化方法,RDB(Redis Database)和 AOF(Append Only File)
- RDB:在指定间隔(小时为单位)新 fork 一个子线程来保存数据集的时间点快照
- AOF:使用后台进程记录服务器接收到的每一个写操作,类似于写日志,这些操作可以在服务器启动时重新执行,以重建原始数据集
从保存的频率、资源的消耗、恢复的速度上来看
- AOF 的持久化更密集(以秒为单位进行记录),但记录的是写命令日志,在恢复时重新进行写,恢复较慢
- 而 RBD 的备份更松散(以小时为单位),且保存更耗费资源,但快照保存的更为完整,允许大数据集快速重启
其中
- 保存的频率决定了数据安全等级,频率越高,数据一致性保障越高,AOF fsync 1s 能够应对突然断电的情况
- 存储的消耗上,AOF 比 RBD 消耗更高,因为快照文件更为紧凑
- 性能上,一般而言 RBD 比 AOF 更好,但即使 fsync 每秒一次,AOF 性能表现仍然不错
值得注意的是:AOF 方式中,即使日志由于某种原因(磁盘满或其他原因)以一个写了一半的命令结束,redis-check-aof 工具能轻松修复
配置数据库持久化 | 文档 - Configure database persistence | Docs (opens new window)
数据库持久化选项
| Options 选项 | Description 描述 |
|---|---|
| None | 完全不持久化到磁盘 |
| Append-only file (AOF) - fsync every write | 数据每次写入命令都 fsync 到磁盘 |
| Append-only file (AOF) - fsync every 1 sec | 数据每次写入命令每秒同步到磁盘 |
| Snapshot, every 1 hour | 数据库每小时创建一次快照 |
| Snapshot, every 6 hours | 数据库每 6 小时创建一次快照 |
| Snapshot, every 12 hours | 数据库每 12 小时创建一次快照 |
# LevelDB
一个基于 Go 编写的内存 KV 数据库,类似于 SQLite 之于关系数据库:GitHub - google/leveldb: LevelDB is a fast key-value storage library written at Google that provides an ordered mapping from string keys to string values (opens new window)
对于 daemon 程序,做 DB 的解耦,选择本地的 KV 数据库是很好的选择,只要一些简单的 Query,通过存一个 Json KV 对就可以满足业务需求
# Redis 缓存
# 穿透击穿和雪崩
缓存穿透:用户始终请求 Redis 缓存和 MySQL 数据库中都不存在的数据,这样会穿透缓存,每次都打在数据库,拖慢应用
- 给这个“不存在的热点数据”存一个值为 null 的缓存
缓存击穿:单点热 Key 过期,对这个 Key 的请求在同时全打在了 MySQL
- 有条件的情况下,缓存不设置有效期;给读 MySQL 加锁,而对读 Redis 不做限制
缓存雪崩:大量缓存同时过期,导致请求全打在 MySQL
- 防止热 Key 统一过期,设置随机的过期时延;设置限流和熔断降级机制,如当数据库压力超过阈值,返回兜底的空数据
三者本质上都是缓存失效,导致数据库的压力,只不过穿透和击穿是“点”的问题,即单个热 Key 的问题,而雪崩是“面”的问题,是大量 Key 同时失效的雪崩,显然后者事故级别远大于前者
如何处理大 Key 和热 Key?
- 大 Key 做字段拆分
- 热 Key 做多级缓存,例如本地缓存
# MySQL 存取与锁
Doc 表设计:canvas-global/model/dao/ddbs/table_doc.go
// Doc 表Doc的结构
type Doc struct {
DocId uint64 `ddb:"doc_id"`
MainStatus uint8 `ddb:"main_status"`
SubStatus uint8 `ddb:"sub_status"`
CreateTime uint32 `ddb:"create_time"`
Cid1 uint16 `ddb:"cid1"`
Cid2 uint16 `ddb:"cid2"`
Cid3 uint16 `ddb:"cid3"`
Type uint8 `ddb:"type"`
Page uint32 `ddb:"page"`
Size uint32 `ddb:"size"`
Price uint32 `ddb:"price"`
Title string `ddb:"title"`
Summary string `ddb:"summary"`
Uid uint64 `ddb:"uid"`
Uname string `ddb:"uname"`
Uip uint32 `ddb:"uip"`
ModifyLock uint8 `ddb:"modify_lock"`
Profit uint32 `ddb:"profit"`
Flag uint32 `ddb:"flag"`
Islock uint8 `ddb:"islock"`
Ishide uint8 `ddb:"ishide"`
TagStr string `ddb:"tag_str"`
StoreId uint64 `ddb:"store_id"`
PcsData string `ddb:"pcs_data"`
UpdateTime uint32 `ddb:"update_time"`
FixedDocId uint64 `json:"fixedDocId,omitempty"` //精编后对应的docid
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
其中 ModifyLock 字段用于锁定用户的写操作,通过将其置 1/0 维护写状态
update doc set modify_lock =1 where doc_id = ? and modify_lock = 0
并发从数据库 DB 中获取数据:canvas-global/library/doc_cache.go: goGetFieldFromDB
// goGetFieldFromDB go func并发的方式从数据库中获取指定field的数据
func goGetFieldFromDB(ctx context.Context, docID uint64, filteredFields []Field, storeID uint64) (map[Field]interface{}, error) {
wg := sync.WaitGroup{}
docWg := sync.WaitGroup{}
mu := sync.Mutex{}
storeIDReady := make(chan struct{})
// 防止storeIDReady重复关闭
var storeIDReadyClosed sync.Once
itemInfoMap := make(map[Field]interface{})
var daoErr error
// storeID 准备就绪
if storeID > 0 {
storeIDReadyClosed.Do(func() { close(storeIDReady) })
}
for _, field := range filteredFields {
// field未注册,业务流程不正常,需要返回error,方便业务发现错误
conf, ok := cMap.m[field]
if !ok {
resource.LoggerService().Fatal(ctx, fmt.Sprintf("cache field not register, field=%s, err=%s", field, ErrFieldNotRegistered))
continue
}
wg.Add(1)
// 对使用docID进行查询的单独计数,因为没有依赖关系
if conf.DaoIDType == DaoIDTypeDocID {
docWg.Add(1)
}
go func(c Config) {
var daoRes interface{}
defer func() {
if r := recover(); r != nil {
mu.Lock()
daoErr = fmt.Errorf("go func run error, err=%v", r)
mu.Unlock()
resource.LoggerService().Fatal(ctx, fmt.Sprintf("go func panic, err=%v", r))
}
if c.DaoIDType == DaoIDTypeDocID {
docWg.Done()
}
wg.Done()
}()
// storeID类型的等待storeID准备就绪
if c.DaoIDType == DaoIDTypeStoreID {
select {
// 等待storeID准备就绪
case <-storeIDReady:
// 超时结束goroutine,防止协程未被正常关闭造成协程泄漏
case <-ctx.Done():
return
}
}
var id uint64
if c.DaoIDType == DaoIDTypeDocID {
id = docID
} else if c.DaoIDType == DaoIDTypeStoreID {
// 检查输入store_id,如果store_id为0,则未获取到storeId,不需要进一步dao操作
if storeID <= 0 {
return
}
id = storeID
}
in := []reflect.Value{
reflect.ValueOf(ctx),
reflect.ValueOf(id),
}
// 注册函数时,保证函数结构为 f(ctx, id)(ptrToS, error)
out := reflect.ValueOf(c.DaoFunc).Call(in)
// 第一个返回值是一个指针,在不为nil的情况下赋值interface{},防止后续逻辑错乱
if !out[0].IsNil() {
daoRes = out[0].Interface()
}
var err error
if out1, ok := out[1].Interface().(error); ok {
err = out1
}
mu.Lock()
// 查询数据库出错,返回
if err != nil && err != mysql.ErrEmptyResult {
daoErr = err
mu.Unlock()
return
}
// 结果为空,设置为nil,
if err == mysql.ErrEmptyResult || daoRes == nil {
itemInfoMap[conf.Field] = nil
mu.Unlock()
return
}
if storeID == 0 && daoRes != nil {
if getter, ok := daoRes.(StoreIDGetter); ok {
storeID = getter.StoreID()
// storeID拿到,广播通知等待storeID的协程
storeIDReadyClosed.Do(func() { close(storeIDReady) })
}
}
itemInfoMap[conf.Field] = daoRes
mu.Unlock()
}(conf)
}
docWg.Wait()
if storeID == 0 {
storeIDReadyClosed.Do(func() { close(storeIDReady) })
}
wg.Wait()
if daoErr != nil {
return itemInfoMap, daoErr
}
return itemInfoMap, nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
# Redis 缓存存取
优先从缓存中取数据:canvas-global/library/doc_cache.go: WithCache
// WithCache 同时获取多个 field 的数据,优先从缓存中读取,不存在则使用传入的 dataOps 读取
func WithCache(ctx context.Context, docID uint64, fields ...Field) (map[Field]interface{}, error) {
itemInfoMap := make(map[Field]interface{})
filteredFields, storeID := getFieldFromCache(ctx, docID, itemInfoMap, fields...)
// 缓存中全部查询完毕,返回
if len(filteredFields) == 0 {
return itemInfoMap, nil
}
// 函数退出时延迟存储缓存
dbResMap := make(map[Field]interface{})
defer func() {
if len(dbResMap) == 0 {
return
}
if err := setCache(ctx, docID, dbResMap); err != nil {
resource.LoggerService().Warning(ctx, fmt.Sprintf("set conv_range info to cache failed, docID=%d, err=%s", docID, err))
}
}()
// 缓存中没有查到的从db查询
dbResMap, err := goGetFieldFromDB(ctx, docID, filteredFields, storeID)
if err != nil {
return itemInfoMap, err
}
// 合并两个map
for field, value := range dbResMap {
itemInfoMap[field] = value
}
return itemInfoMap, nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
在 WithCache 退出时对 dbResMap 进行缓存,若命中了 DB 则缓存,并设置随机超时时间防止雪崩
canvas-global/library/doc_cache.go: setCache
// setCache 保存数据到缓存中,支持保存多个field的数据
func setCache(ctx context.Context, id uint64, dataMap map[Field]interface{}) error {
if len(dataMap) == 0 {
return fmt.Errorf("SetCache: dataMap is empty")
}
var cacheErr error
dataSlice := make([]interface{}, 0, len(dataMap)*2)
for field, data := range dataMap {
// field未注册,业务流程不正常,需要返回error,方便业务发现错误
conf, ok := cMap.m[field]
if !ok {
resource.LoggerService().Fatal(ctx, fmt.Sprintf("cache field not register, field=%s, err=%s", field, ErrFieldNotRegistered))
continue
}
// 过期时间添加随机浮动
expire := conf.ExpireTime + (time.Duration(rand.Int63n(randTimeRange)) * time.Second)
// 对每个field的数据进行处理
var err error
var s []byte
// 如果写入的数据是nil,存入空值
if data == nil {
cd := packCacheData(string(s), field, expire)
dataSlice = append(dataSlice, string(field), cd)
continue
}
if reflect.TypeOf(data).Kind() != reflect.Ptr {
cacheErr = fmt.Errorf("%s field data should give a ptr, but type=%T; %s", field, data, cacheErr)
continue
}
// 检查是否有自定义的marshal方法
if v, ok := data.(Marshaler); ok {
s, err = v.MarshalCache()
} else {
s, err = defaultMarshaler(data)
}
if err != nil {
cacheErr = fmt.Errorf("marshal data failed, id=%d, field=%s, err=%s; %s", id, field, err, cacheErr)
continue
}
cd := packCacheData(string(s), field, expire)
dataSlice = append(dataSlice, string(field), cd)
}
key := generateKey(id)
sc := resource.Redis().DocPush.HMSet(ctx, key, dataSlice...)
if sc.Err() != nil {
return fmt.Errorf("hmset failed, key=%s, err=%s; %s", key, sc.Err(), cacheErr)
}
_, err := sc.Result()
if err != nil {
return fmt.Errorf("hmset failed, key=%s, err=%s; %s", key, err, cacheErr)
}
// 给过期时间加上随机值,防止击穿
expireTime := defaultKeyExpireTime + (time.Duration(rand.Int63n(randTimeRange)) * time.Second)
sc = resource.Redis().DocPush.Expire(ctx, key, expireTime)
if sc.Err() != nil {
resource.LoggerService().Warning(ctx, fmt.Sprintf("set expire error, key=%s, err=%s", key, sc.Err()))
}
if ok, err := sc.Result(); err != nil || !ok {
resource.LoggerService().Warning(ctx, fmt.Sprintf("set expire error, key=%s, err=%s", key, err))
}
return cacheErr
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
# Redis 消息队列
文件转码服务
# 架构
文档处理 Redis MQ
- 生产者:canvas-global/model/service/frcanv/basis/convbase.go,失败重试机制,Redis SETNX 上锁
- 消费者:canvas-global/cmdtask/smappsynctask/canvs/fileparsetask.go,协程池消费,令牌桶限流,AddToken 上锁
缺点:消息可能丢失(进程崩溃时未 ACK 的任务)、没有持久化保证
架构概览
┌─────────────────┐ Redis List ┌─────────────────┐
│ 生产者 │ ──────────────────────> │ 消费者 │
│ (convbase.go) │ LPush ⮕ [任务1, 任务2] ⬅ RPop │ (fileparsetask) │
│ │ │ │
└─────────────────┘ └─────────────────┘
2
3
4
5
Redis 数据结构
canvastob_file_img_queue (List)
├── {"CanvasDocID":"xxx","ElementID":"yyy","RetryCount":0,...}
├── {"CanvasDocID":"aaa","ElementID":"bbb","RetryCount":1,...}
└── ...
canvastob_img_global_bucket (List - 令牌桶)
├── "token1"
├── "token2"
└── "token3"
canvastob_img_bucket_lock (String - 分布式锁)
└── "instance-uuid-xxx"
2
3
4
5
6
7
8
9
10
11
12
组件
| 组件 | Redis 操作 | 作用 |
|---|---|---|
| 生产者 | LPush | 推任务到尾部 |
| 消费者 | RPop | 从队头取任务 |
| 分布式锁 | SetNX | 防止多实例重复补充令牌 |
| 令牌桶 | LPush + RPop | 控制全局 QPS 限流 |
# 生产者
生产者推送任务
func CanvasFileEnqueue(ctx context.Context, params *ConvertSubmitParams, isImg bool) error {
// 根据文件类型选择队列
queueKey := GetTaskNotImgQueueKey()
if isImg {
queueKey = GetTaskImgQueueKey()
}
// 序列化任务参数
value := SerializeSubmitParams(ctx, params)
if value == "" {
return wkerror.New(wkerror.ErrorCodeInternalError, "failed to serialize request")
}
// LPush 将任务推入队列头部
err := resource.Redis().DocPush.LPush(ctx, queueKey, value).Err()
if err != nil {
resource.LoggerService().Error(ctx, "failed to push to queue", logit.Error("error", err))
return wkerror.New(wkerror.ErrorCodeInternalError, "failed to enqueue request")
}
return nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
一些常量定义
const (
// 自由画布单实例任务控制相关常量
TaskMaxRetryTimes = 2 // 任务执行失败重试最大次数
TaskImgSubmitPoolNum = 2 // 图片类型-最大并发量,控制 QPS
TaskNotImgSubmitPoolNum = 5 // 非图片类型-最大并发量,控制 QPS
// 自由画布全局桶控制相关常量
TaskImgSubmitWholeQPS = 3 // 图片类型- 全局QPS
TaskNotImgSubmitWholeQPS = 12 // 非图片类型-全局QPS
QueueCheckInterval = time.Millisecond * 1000 // 任务队列查询间隔
FileTokenBucketLockExpire = 2 * time.Second // 令牌桶锁过期时间
FileImgBucketLock = "canvastob_img_bucket_lock" // 令牌桶锁 - 图片
FileImgGlobalBucket = "canvastob_img_global_bucket" // 文件上传全局令牌桶 - 图片
FileNotImgBucketLock = "canvastob_not_img_bucket_lock" // 令牌桶锁 - 非图片
FileNotImgGlobalBucket = "canvastob_not_img_global_bucket" // 文件上传全局令牌桶 - 非图片
)
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
任务参数结构体
type ConvertSubmitParams struct {
CanvasDocID string
ElementID string
UID uint64
UName string
FileName string
FileExt string
FileSize int64
ParseInfo Parse
OriginObject string
Source string
Bucket string
OriginURL string
From int
Channel string
IsWPFolder bool
IsNote bool
// 异步任务重试次数
RetryCount int
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 消费者
协程池消费
// 调度器结构体
type CanvasFileScheduler struct {
IsImg bool
qps int
taskQueueKey string
globalBucket string
globalBucketLock string
}
// 各实例控制qps: 协程池
func (c *CanvasFileScheduler) StartCanvasFileScheduler(ctx, signContext context.Context) error {
pNum := basis.TaskNotImgSubmitPoolNum
pKey := basis.GetTaskNotImgQueueKey()
if c.IsImg {
pNum = basis.TaskImgSubmitPoolNum
pKey = basis.GetTaskImgQueueKey()
}
var pool, err = ants.NewPool(pNum)
if err != nil {
resource.LoggerService().Warning(ctx, "NewPool error", logit.Error("err", err))
return err
}
// 等待所有任务执行结束
defer func() {
for {
resource.LoggerService().Notice(ctx, "StartCanvasSubmit waiting worker pool end", logit.AutoField("pool-count", pool.Free()))
if pool.Free() == pNum {
resource.LoggerService().Notice(ctx, "StartCanvasSubmit worker pool end!")
break
}
time.Sleep(1 * time.Second)
}
}()
for signContext.Err() == nil {
// if worker pool is busy
if pool.Free() == 0 {
continue
}
// 从 Redis 队列中拉取消息
value, err := resource.Redis().DocPush.RPop(ctx, pKey).Result()
if err == redis.Nil {
// 队列为空,继续
time.Sleep(basis.QueueCheckInterval)
continue
} else if err != nil {
resource.LoggerService().Error(ctx, "failed to pop from queue", logit.Error("error", err))
continue
}
submitParams := basis.DeserializeSubmitParams(ctx, value)
if submitParams == nil {
continue
}
_ = pool.Submit(func() {
// 捕获 panic,防止影响主程
defer func() {
if r := recover(); r != nil {
resource.LoggerService().Error(ctx, "worker task panic", logit.AutoField("recover", r))
// 可重新添加任务到队列
}
}()
// 执行任务
err := basis.ConvertSubmit(ctx, submitParams)
if err != nil {
resource.LoggerService().Error(ctx, "convert submit error", logit.Error("error", err))
// 失败重试处理
submitParams.RetryCount++
if submitParams.RetryCount <= basis.TaskMaxRetryTimes {
resource.LoggerService().Notice(ctx, "retrying task", logit.AutoField("retryCount", submitParams.RetryCount))
value := basis.SerializeSubmitParams(ctx, submitParams)
if value != "" {
// 重新添加任务到队列
resource.Redis().DocPush.LPush(ctx, pKey, value)
}
} else {
resource.LoggerService().Error(ctx, "task failed after max retries", logit.AutoField("params", submitParams))
}
}
})
}
return nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
令牌桶消费
// 全局控制qps:令牌桶控制,整体限流
func (c *CanvasFileScheduler) StartFileSchedulerWhole(ctx, signContext context.Context) error {
c.qps = basis.TaskNotImgSubmitWholeQPS
c.taskQueueKey = basis.GetTaskNotImgQueueKey()
c.globalBucket = basis.FileNotImgGlobalBucket
c.globalBucketLock = basis.FileNotImgBucketLock
if c.IsImg {
c.qps = basis.TaskImgSubmitWholeQPS
c.taskQueueKey = basis.GetTaskImgQueueKey()
c.globalBucket = basis.FileImgGlobalBucket
c.globalBucketLock = basis.FileImgBucketLock
}
instanceID := uuid.New().String()
// 定时向 Redis 中添加令牌
go func() {
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for {
select {
case <-signContext.Done():
resource.LoggerService().Notice(ctx, "restart project, stop add token")
return
case <-ticker.C:
if err := c.AddToken(ctx, instanceID); err != nil {
time.Sleep(basis.QueueCheckInterval)
resource.LoggerService().Error(ctx, "failed to add token", logit.AutoField("error", err))
continue
}
}
}
}()
// 消费队列中的请求
go func() {
for {
select {
case <-ctx.Done():
resource.LoggerService().Notice(ctx, "restart project, stop consume queue")
return
default:
if err := c.ConsumeQueue(ctx); err != nil {
time.Sleep(basis.QueueCheckInterval)
continue
}
}
}
}()
return nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
消费动作和添加令牌
func (c *CanvasFileScheduler) ConsumeQueue(ctx context.Context) error {
// 从 Redis 的全局桶中取令牌
token := basis.GetRedisIns(ctx).RPop(ctx, c.globalBucket)
if token.Err() == redis.Nil {
return wkerror.New(wkerror.ErrorCodeInternalError, "consume acquire lock nil")
} else if token.Err() != nil {
return wkerror.New(wkerror.ErrorCodeInternalError, "consume acquire lock error")
}
// 取到令牌后,处理请求
value, err := basis.GetRedisIns(ctx).RPop(ctx, c.taskQueueKey).Result()
if err == redis.Nil {
return wkerror.New(wkerror.ErrorCodeInternalError, "consume get task nil")
} else if err != nil {
return wkerror.New(wkerror.ErrorCodeInternalError, "consume get task error")
}
submitParams := basis.DeserializeSubmitParams(ctx, value)
if submitParams == nil {
return wkerror.New(wkerror.ErrorCodeInternalError, "consume get task params nil")
}
resource.LoggerService().Notice(ctx, "canvas consume task start", logit.AutoField("params", submitParams))
go HandleTask(ctx, c.taskQueueKey, submitParams)
return nil
}
func HandleTask(ctx context.Context, queueKey string, submitParams *basis.ConvertSubmitParams) {
// 捕获 panic,防止影响主程序
defer func() {
if r := recover(); r != nil {
resource.LoggerService().Error(ctx, "worker task panic", logit.AutoField("recover", r))
// 可重新添加任务到队列
value := basis.SerializeSubmitParams(ctx, submitParams)
if value != "" {
// 重新添加任务到队列
basis.GetRedisIns(ctx).LPush(ctx, queueKey, value)
}
}
}()
// 执行任务
err := basis.ConvertSubmit(ctx, submitParams)
if err != nil {
resource.LoggerService().Error(ctx, "convert submit error", logit.Error("error", err))
// 失败重试处理
submitParams.RetryCount++
if submitParams.RetryCount <= basis.TaskMaxRetryTimes {
resource.LoggerService().Notice(ctx, "retrying task", logit.AutoField("retryCount", submitParams.RetryCount))
value := basis.SerializeSubmitParams(ctx, submitParams)
if value != "" {
// 重新添加任务到队列
basis.GetRedisIns(ctx).LPush(ctx, queueKey, value)
}
} else {
resource.LoggerService().Error(ctx, "task failed after max retries", logit.AutoField("params", submitParams))
}
}
resource.LoggerService().Notice(ctx, "canvas consume task end", logit.AutoField("params", submitParams))
}
func (c *CanvasFileScheduler) AddToken(ctx context.Context, instanceID string) error {
// 尝试获取分布式锁
lockAcquired, err := basis.GetRedisIns(ctx).SetNX(ctx,
c.globalBucketLock, instanceID, basis.FileTokenBucketLockExpire).Result()
if err != nil {
return wkerror.New(wkerror.ErrorCodeInternalError, "failed to acquire lock")
}
if lockAcquired {
tokenCount, err := basis.GetRedisIns(ctx).LLen(ctx, c.globalBucket).Result()
if err != nil {
return wkerror.New(wkerror.ErrorCodeInternalError, "failed to get token count")
}
// 计算需要添加的令牌数量
tokensToAdd := c.qps - int(tokenCount)
if tokensToAdd > 0 {
for i := 0; i < tokensToAdd; i++ {
basis.GetRedisIns(ctx).LPush(ctx, c.globalBucket, instanceID)
}
}
// 释放锁(确保释放锁时候还是自己持有)
currentLockOwner, err := basis.GetRedisIns(ctx).Get(ctx, c.globalBucketLock).Result()
if err == nil && currentLockOwner == instanceID {
basis.GetRedisIns(ctx).Del(ctx, c.globalBucketLock)
}
}
return nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
# 分布式 Redis
# Redis 分布式锁
一般为了保证分布式系统的性能,分布式锁一般都是乐观锁,与之对应的是悲观锁
- 悲观锁就是 synchronized,是一种严苛的公平锁,先来后到,先走了后才能进
- 乐观锁可以理解为 git 的 commit,只在 push 的时候对版本进行检查,版本就是这里的乐观锁
当然,我们在此处只讨论分布式锁的实现,需要明确的是,分布式锁既可以是悲观的也可以是乐观的,这要根据具体场景进行设计考量
- 例如:Redission,基于 Redis 集群的分布式锁,本质上就是维护同一个键值对,作为 Lock,获取时上锁,获取前检查这个键值对是否有锁,释放时解锁
# Redis 事物
Redis + Lua 脚本是实现事务的常见搭配
事物:一组命令的集合,如多条 SQL,入队出队依次执行,事物中的所有命令都会被序列化并按顺序执行,事务中的多条 SQL 作为一个整体,要么都成功,要么都失败
ACID 原则:原子性、一致性、隔离性、持久性
- redis 单条命令保证原子性,但 redis 事物不保证原子性
- redis 事务没有隔离级别的概念,所有命令在事务中并没有直接被执行,只有发起执行命令的时候才会执行(exec)
redis 事务的一次正常执行
- 开启事务:multi
- 命令入队:依次写命令
- 执行事务:exec
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) OK
4) "v2"
2
3
4
5
6
7
8
9
10
11
12
13
14
15
放弃事务:discard(在 multi 后、exec 前执行,队列中所有命令都不会执行)
事务报错:编译型异常,代码有问题,编译都过不了,整个事务都不会被执行
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> getset k3
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379(TX)> get k1
(nil)
2
3
4
5
6
7
8
9
10
11
12
13
运行时异常:如果事务队列中某个命令存在某个问题,类似与 RuntimeException,在执行事务时,其他命令可以正常执行,错误命令抛出异常
127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incr k1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> exec
1) (error) ERR value is not an integer or out of range
2) OK
3) "v2"
127.0.0.1:6379>
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Redis 主从同步
Redis 主从架构如何避免脏读
- 考考你Redis主从,就知道有没深入Redis大家好,我是南哥。 一个对Java程序员进阶成长颇有研究的人,今天继续给大 - 掘金 (opens new window)
- Redis部署方案的演进-腾讯云开发者社区-腾讯云 (opens new window)
在 Redis 主从架构中
- 主节点:负责处理写操作(如 SET、DEL),并将写操作同步到从节点
- 从节点:负责处理读操作(如 GET),并提供数据的副本
这也是 CQRS 的一种具体实现,即读写分离架构
在 Redis 集群中,这样的复制和 Eureka 一样,属于异步复制,均属于 AP 系统(可用性大于一致性)
- 由于主从同步是异步的,写操作在主节点完成后,并不会立即同步到从节点,因此在同步完成之前,从节点可能会返回旧数据,导致脏读
一个很经典的避免脏读的方法:读写锁(写时禁读)
但经典的解决方案导致经典的问题
- 性能瓶颈:写操作期间禁止读操作,会导致读请求被阻塞,降低系统的并发性能
- 系统卡死:若主节点的写 I/O 阻塞,整个系统可能会卡住,影响可用性
- 复杂性:实现分布式读写锁会增加系统的复杂性
主从结构下,避免脏读除了读写锁还有什么方法呢?(天美 /(ㄒoㄒ)/~~)
1️⃣ 写后同步等待:刚刚提到,用读写锁,实际上是分布式锁的一种应用,这与“写后同步等待”不同,“写后同步等待”实际上就类似于 Eureka 的同步复制机制,主节点写完后对所有副节点进行阻塞的同步更新,更新完成后,才可以执行读操作
这可以使用 Redis 的 Wait 命令实现
SET key value
WAIT 1 1000 # 等待至少 1 个从节点同步完成,超时时间为 1000 毫秒
2
2️⃣ 版本号或时间戳机制:为每个键(Key)添加版本号或时间戳,客户端在读取数据时检查版本号或时间戳,确保读取的是最新数据
- 优点:不需要阻塞读操作,性能较高;可以灵活控制数据的一致性级别
- 缺点:需要在客户端实现额外的逻辑;增加了数据存储的开销(多一个存储字段)
实现方式:在写操作时,更新键的版本号或时间戳
SET key:version 1
SET key:value "data"
2
在读操作时,检查版本号或时间戳
GET key:version
GET key:value
2
这里的读是指一次事务中的前后两次读(脏读的本质),在后一次做一个版本的检查,比如刚进入时读一次数据(这个数据上带一个版本号,或时间戳),然后在退出函数时再读一次,若版本号不同,则按后一次读出的数据为准
3️⃣ 最终一致性容忍:接受一定时间内的脏读,通过业务逻辑容忍最终一致性
- 优点:性能高,没有额外的同步开销;适合对一致性要求不高的场景
- 缺点:不适用于对一致性要求严格的场景(如金融交易)
实现方式:在业务逻辑中处理脏读问题,例如
- 对脏读不敏感的数据(如用户昵称、文章内容)直接使用从节点读取
- 对脏读敏感的数据(如余额、库存)可以从主节点读取
注意,我们可以强制用户在主节点上读取数据,这样可以保证不会出现脏读,代价是主节点负担较大,所以这里的实现采取了折中的方案,敏感数据限定读主节点,非敏感数据读副节点
“最终一致性容忍”就是指允许了短时间的脏读,但换回了相当一部分的性能
4️⃣ 强制读主节点:对于敏感数据,强制性的让用户只能读取主节点内容,由于 Redis 是单线程的原子操作,单独读写一个节点,就不会发生脏读
随之而来的是主节点负担增加,从而拖慢读写性能
# Redis 限流与过滤
# API 令牌桶限流
对于 API 请求,Redis 单线程记录 IP 对 API 每分钟的请求次数,超出则在 Controller 中拒绝访问,例如
- 用户提交成功后,在收到返回前,不能重复提交
- 用户在 5s 以内只能成功提交一次
这样需要对这个接口上两道锁
- 执行锁,限定单个用户对同一道题在同一时刻只能判一次
- 频控锁,限定单个用户对同一道题在 5s 内只能判题一次
执行锁使用 Redis 的原子锁,SET NX + EX 实现,控制字段
SET docker:lock:{uid}:{qid} requestId NX EX 300
这个字段的键由用户 ID 和题目 ID 构成,值为本次提交的请求 ID
NX:不存在才设置EX 300:兜底超时,防止执行锁卡死
只需要在判题前加入一个 Redis 的判断即可
boolean locked = redis.setIfAbsent(
"docker:lock:" + uid + ":" + qid,
requestId,
300
);
if (!locked) {
return "请勿重复提交任务";
}
2
3
4
5
6
7
8
9
在判题结束后,需要释放执行锁
finally {
releaseLock("docker:lock:" + uid + ":" + qid, requestId);
}
2
3
频控锁:使用 Redis 的冷却锁实现
SET docker:freq:{uid}:{qid} 1 NX EX 5
即设置一个 5s 超时时间的键值对,键同样由用户 ID 和题目 ID 构成,在判题前进行拦截
boolean allowed = redis.setIfAbsent(
"docker:freq:" + uid,
"1",
5
);
if (!allowed) {
return "操作频繁";
}
2
3
4
5
6
7
8
9
执行流程如下
请求进来
↓
校验身份 / IP
↓
【1】尝试获取执行锁(docker:lock)
失败 → 直接拒绝
↓
【2】尝试获取 5s 频控锁(docker:freq)
失败 → 释放执行锁 → 拒绝
↓
【3】真正执行 docker
↓
【4】finally 中释放执行锁
2
3
4
5
6
7
8
9
10
11
12
13
为什么频控在执行锁之后?更直觉的处理,先判断有没有锁进门,再判断能进多少人,这个优先级要搞清
- 如果频控先于执行,在第一秒和第六秒都有人来打请求,那么两个请求都能通过频控锁,而第一秒的请求没结束,所以第六秒的请求会消耗执行锁的判断(一共是四次判断)
- 如果执行先于频控,上述事件就会少一次判断(三次判断),那另一种情况下,第一秒和第四秒都有请求打进来,并且已经执行完,那么也会有四次判断,但这里由于频率过高会被第四次判断拦截,这正是我想要的结果
就是说,我一定要先判断有没有进入的权限,再判断是否达标,否则我没有必要判断是否达标,懂我意思吗
# Redis 限流器
Redis 限流算法
- 令牌桶算法:每秒限定令牌数量,平滑限流并支持突发流量
- 漏桶算法:每秒处理多少请求,严格控制请求速率
- 固定窗口算法:固定时间窗口中的请求数量,对限流精度要求不高
- 滑动窗口算法:较于固定窗口更为细腻,时间窗口可变,对限流精度要求较高
- 动态限流算法:根据系统负载动态调节漏桶的流速
GitHub - throttled/throttled: Package throttled implements rate limiting access to resources such as HTTP endpoints (opens new window):一个基于 GCRA 算法(Generic cell rate algorithm)的 go 限流器,存储基于 Redis
type RedisClientProvider func() trpcredis.Client
type RedisGCRALimiter struct {
provider RedisClientProvider
mu sync.Mutex
limit int
limiter throttled.RateLimiterCtx
}
func NewRedisGCRALimiter(provider RedisClientProvider) *RedisGCRALimiter {
return &RedisGCRALimiter{provider: provider}
}
func (l *RedisGCRALimiter) Allow(ctx context.Context, key string, limit int) (bool, error) {
if limit <= 0 {
return true, nil
}
limiter, err := l.rateLimiter(limit)
if err != nil {
return true, err
}
limited, _, err := limiter.RateLimitCtx(ctx, key, 1)
if err != nil {
return true, err
}
return !limited, nil
}
func (l *RedisGCRALimiter) rateLimiter(limit int) (throttled.RateLimiterCtx, error) {
l.mu.Lock()
defer l.mu.Unlock()
if l.limiter != nil && l.limit == limit {
return l.limiter, nil
}
maxBurst := limit - 1
if maxBurst < 0 {
maxBurst = 0
}
store, err := redigostore.NewCtx(redisConnProvider{provider: l.provider}, "", 0)
if err != nil {
return nil, err
}
limiter, err := throttled.NewGCRARateLimiterCtx(store, throttled.RateQuota{
MaxRate: throttled.PerDuration(limit, time.Second),
MaxBurst: maxBurst,
})
if err != nil {
return nil, err
}
l.limiter = limiter
l.limit = limit
return l.limiter, nil
}
type redisConnProvider struct {
provider RedisClientProvider
}
func (p redisConnProvider) Get() redigo.Conn {
if p.provider == nil {
return redisErrorConn{err: errors.New("redis client not initialized")}
}
client := p.provider()
if client == nil {
return redisErrorConn{err: errors.New("redis client not initialized")}
}
conn, err := client.Pipeline(context.Background())
if err != nil {
return redisErrorConn{err: err}
}
return redisConn{Conn: conn}
}
type redisConn struct {
redigo.Conn
}
func (c redisConn) Do(commandName string, args ...interface{}) (interface{}, error) {
if strings.EqualFold(commandName, "SELECT") {
return "OK", nil
}
return c.Conn.Do(commandName, args...)
}
type redisErrorConn struct {
err error
}
func (c redisErrorConn) Close() error {
return nil
}
func (c redisErrorConn) Err() error {
return c.err
}
func (c redisErrorConn) Do(string, ...interface{}) (interface{}, error) {
return nil, c.err
}
func (c redisErrorConn) Send(string, ...interface{}) error {
return c.err
}
func (c redisErrorConn) Flush() error {
return c.err
}
func (c redisErrorConn) Receive() (interface{}, error) {
return nil, c.err
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
# Redis 布隆过滤器
利用 Redis 模块组件 Redis BF 实现布隆过滤器
布隆过滤器:通过二进制位哈希快速实现“是否存在”的判断 HashSet.ContainsKey(),以实现白名单、黑名单等过滤逻辑