并发和锁
# 生产消费和锁
只要是并发编程必须要加锁
# 生产消费关系
生产消费关系:线程通信流程为“判断等待 → 执行业务 → 通知解锁”
- 虚假唤醒:判断等待使用 if 判断,唤醒后线程会从 wait 之后的代码开始运行,但是不会重新判断 if 条件,直接继续运行 if 代码块之后的代码(if 判断在第一进入的适合),而如果使用 while 的话,会再次进行判断
例如一个具体买卖的等待唤醒场景,由于买卖关系的严肃性(防超卖、防超扣),必须实现对线程的精确控制
class Shoes{
int num = 5;
//用状态码去判断是否让线程等待
int status = 1;
Lock l = new ReentrantLock();
Condition c1 = l.newCondition();
Condition c2 = l.newCondition();
Condition c3 = l.newCondition();
Condition c4 = l.newCondition();
public void sale(){
l.lock();
try{
while(num<=0 || status!=1){
c1.await();
}
System.out.println(Thread.currentThread().getName()+":当前库存" + num + ",售出一件,剩余" + (--num));
status = 2;
c2.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
l.unlock();
}
}
public void transfer(){
l.lock();
try{
while(status!=2){
c2.await();
}
System.out.print(Thread.currentThread().getName()+":开始运送鞋子 ——> ");
TimeUnit.SECONDS.sleep(2);
System.out.println("运送到家");
status = 3;
c3.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
l.unlock();
}
}
public void sign(){
l.lock();
try{
while(status!=3){
c3.await();
}
System.out.println(Thread.currentThread().getName() + ":用户已签收\n");
status = 1;
c1.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
l.unlock();
}
}
}
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
通常而言,消费者通过“回调”的方式告知生产者消费结果,生产者通常是我们程序的控制面
# 锁的分类
# 悲观锁和乐观锁
悲观锁:synchronized,乐观锁:CAS
悲观锁:上面的 SetNX 就是天然的分布式悲观锁(Redis 单线程),同一时间只有一个操作者独占锁,其他请求必须等待,适合冲突频繁的场景
乐观锁:不阻塞,多个操作可以并行,可以通过版本号来检测冲突,只有用户当前的版本号和服务器的版本号一致的情况,才允许修改数据,适合冲突少的场景,性能优于悲观锁,有一点要注意的是,更新版本号的操作必须要上锁,这得是一个原子操作,常见的乐观锁实现
- 基于版本号实现:在数据上新增一个版本号字段,例如通过
newVersion := currentVersion + 1实现 - 基于时间戳实现:和版本号差不多,一个道理,只不过更新的数据从版本号变成当前时间戳
- 基于 CAS(Compare And Swap)实现:版本号的优化版本
基于版本号的 CAS 示例
// SaveBDJsonWithCAS 使用CAS实现乐观锁
func SaveBDJsonWithCAS(ctx context.Context, req *SaveBDJsonParam) error {
versionKey := fmt.Sprintf(DocVersionKey, req.DocID)
// 重试机制,上限为 3
maxRetries := 3
for i := 0; i < maxRetries; i++ {
// 1. 获取当前版本
currentVersion, err := resource.Redis().PegaDocOther.Get(ctx, versionKey).Int64()
if err != nil && err != redis.Nil {
return err
}
// 2. 检查版本(首次保存时跳过)
if req.Version != 0 && req.Version != currentVersion {
return &ConflictError{
CurrentVersion: currentVersion,
Message: "文档已被其他用户修改,请刷新后重试",
}
}
// 3. CAS操作:只有当版本没变时才更新
newVersion := currentVersion + 1
updated, err := resource.Redis().PegaDocOther.SetNX(ctx, versionKey, newVersion, 0).Result()
if err != nil {
return err
}
if updated {
// CAS成功,保存BDJSON
return saveBDJsonToBOS(ctx, req)
}
// CAS失败,版本被修改,重试
resource.LoggerService().Warning(ctx, "CAS failed, retrying",
logit.Int64("retry", int64(i+1)))
}
return errors.New("保存失败,请重试")
}
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
# 非公平锁和公平锁
非公平锁:synchronized,公平锁:ReentrantLock(true)
公平锁 / 非公平锁和乐观锁 / 悲观锁是一组正交的概念,他们讨论的是两类问题
- 乐观锁和悲观锁关注的是如何处理冲突,即具体实施,是通过 SetNX 还是通过版本号
- 公平锁和非公平锁关注的是锁的获取,是 FIFO 还是饥饿抢占,即等待锁的排队顺序是否“公平”
例如:对于公平锁,如果有三个请求 a、b、c 按顺序打到互斥资源,那么锁的获取将按照 a、b、c 的顺序;但若是非公平锁,每一次锁释放,都会重新进行抢占,第一次 a 抢到了,释放后,b 和 c 重新进行抢占,谁抢到就是谁的,这时候要是又来一个请求 d,d 也有可能在 c 前面抢到锁,导致 c 饥饿(非公平,先来但抢不到)
公平锁
- 严格按照请求顺序(FIFO)
- 不会饥饿
- 性能相对较低(需要维护队列)
非公平锁特点
- 不保证请求顺序,后来的可能先获得锁
- 性能高(不需要维护队列)
- 可能产生饥饿(某个请求一直抢不到)
进一步看,非公平锁有独占互斥的前置条件,即必须独占,才有饥饿等待,这指向悲观锁(因为乐观锁其实不会锁住),也就是说,只有悲观锁才会发生非公平的现象,乐观锁不需要考虑公平性,因为没有真正的阻塞
- 非公平悲观锁:如画布的风控锁,每个请求直接去拿 SetNX 锁
- 公平悲观锁:用 Redis List 排队去拿 SetNX 锁
Java AQS 公平锁:AQS 是 AbstractQueuedSynchronizer(抽象队列同步器)的缩写,是 Java 并发包(JUC)中的核心框架,通过一个 state 变量 + 一个 FIFO 队列来实现同步
在 Java 里,ReentrantLock 默认是非公平的,采用 CAS 检查,若构造为公平,则会利用 AQS 队列实现 FIFO,以实现公平锁
// ReentrantLock 默认非公平
ReentrantLock lock = new ReentrantLock();
// ReentrantLock 公平模式
ReentrantLock lock = new ReentrantLock(true);
2
3
4
5
# 互斥锁和信号量
互斥锁:就是独占锁,例如基于 SetNX 实现的悲观锁、Java 里的 synchronized 锁和默认的 ReentrantLock 锁
信号量:通过一个变量控制并发数量,如 JUC 里的 CountDownLatch
CountDownLatch cdl = new CountDownLatch(10); // 同时允许 10 个并发
countDown(); // 减一
await(); // 加锁,当 cdl 减为 0 的时候阻塞
2
3
读写锁是信号量的一个实例,一般而言,“写”使用互斥锁保证同时只有一个在写,而读操作利用信号量机制,同时允许 10 个用户去读(或者压根不对读加锁)
信号量机制和互斥锁有本质区别,互斥锁的上锁解锁,必须由同一人触发,但信号量的“解锁”,可以是任意一个拿到信号量的线程去放开,这里在逻辑上存在一个优先级的判断
值得区分的是:互斥锁和是否公平没有必然联系,但互斥锁大多数情况下默认是非公平的,例如 synchronized 和默认的 ReentrantLock,都是互斥非公平锁,但 ReentrantLock 也可以利用 AQS 排队实例化为公平锁
# 分段锁和桶级锁
全局锁、分段锁和桶级锁是锁细粒度层面的区分
分段锁其实在很多地方都有应用,例如数据库的行级锁,一次事务只锁一行,如果用全局锁锁整个表将会是灾难,其核心思路即:把一整个共享资源拆成多个独立分段,每一段配一把独立锁;不同分段的线程互不阻塞、并发执行,仅同一段内才会锁竞争,降低全局锁的竞争、提升高并发吞吐
- 还有一个例子,腾讯文档的协同编辑,每一个数据块实际上是一个操作单元,后写会覆盖前写(这里没有加锁,采用的 Last Write Wins 的策略,追求性能),不同的数据块可以同时写
一般的处理步骤入戏
- 将大集合 / 大资源(哈希表、库存、计数器)均匀划分为 N 个独立段(Segment),每段存储一部分数据
- 段独立锁:每个分段自带一把独立互斥锁,段与段之间锁完全隔离
- 路由定位:通过
key.hash % 分段数哈希取模,把操作路由到对应分段 - 局部加锁:读写仅锁住当前分段,不影响其他所有分段
JDK 7 中的 ConcurrentHashMap 就是采用的分段锁处理
- 一个 ConcurrentHashMap 默认分成 16 个 Segment 分段,每个 Segment 是一个独立小哈希表 + 一把
ReentrantLock锁 - 增删改:先通过 key 哈希定位到分段 → 只锁住该分段 → 操作
- 查询:无锁直接读,读写并发友好
- JDK8 及之后:废弃分段锁,改用 CAS + 数组桶级 synchronized 细粒度锁,粒度更细、开销更低
为什么要从分段锁改成 synchronized 的桶级锁?桶是什么,桶就是哈希链表的头
synchronized被优化了,偏向锁 → 轻量级锁(自旋 CAS)→ 重量级锁,大部分情况性能碾压 ReentrantLocksynchronized是 JVM 原生指令,更轻量,不用额外创建 Lock 对象,代码实现简单,不用手动加解锁- 锁粒度极小(仅桶头节点),竞争极低,synchronized 完全够用
二者对比
| 锁类型 \ 特点 | 锁 | 锁住范围 | 并发度 | 问题 |
|---|---|---|---|---|
| JDK7 分段锁 | 16 个 Segment,1 个 Segment 一把锁 | 分段内所有桶 | 最高 16 个线程同时修改 | 同分段不同桶依然互斥 |
| JDK8 桶级锁 | 每一个数组桶单独一把锁(锁头节点) | 当前这一个桶 | 理论上 = 数组长度(几千级别) | 只有同一个桶多线程操作才互斥,不同桶完全并行 |
# 可重入锁、自旋锁和死锁
递归锁:只要拿到了外面的锁,就自动拿到了内部的锁,如一个同步方法中调用了另一个同步方法,在单个线程拿到外部方法的锁时,也自动同时拿到了内部同步方法的锁
可重入锁:ReentrantLock 锁可以重复上锁,但 lock 和 unlock 必须配对,否则就会死锁,可重入就是指可以重复上锁
Lock lock = new ReentrantLock();
public void a() {
lock.lock();
System.out.println("方法a加锁");
b(); // 调用方法b
lock.unlock();
}
public void b() {
lock.lock(); // 同一个线程,再次加同一把锁!
System.out.println("方法b加锁");
lock.unlock();
}
2
3
4
5
6
7
8
9
10
11
12
13
14
每一次上锁 state 加一,解锁 state 减一,直到 state = 0,锁才真正释放 —— 一个区分加锁者的信号量(只有加锁者能够解锁)
synchronized 是天然的可重入锁,递归锁到方法 b,调用方法 a 完全正常,不会死锁
public synchronized void a(){
System.out.println("a加锁");
b();
}
public synchronized void b(){
System.out.println("b加锁");
}
2
3
4
5
6
7
8
为什么要用可重入锁,以 CHM 为例:CHM 内部方法嵌套调用非常多,比如 put 里面会调用扩容、调用节点插入、调用计数方法,层层调用都要加同一把分段锁,必须可重入,否则直接死锁
自旋锁(Spin Lock):AtomicInteger 的 getAndIncrement 方法用了自旋锁,本质上是一个do{} while()循环
// 在 AtomicInteger 的 getAndIncrement 方法中 ——> var1=AtomicInteger.class(地址),var2=AtomicInteger.get()(当前值),var4=1
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
//自旋锁
do {
//获取当前值:从地址上读取
var5 = this.getIntVolatile(var1, var2);
}
//与上类似,执行一个CAS(比较交换)函数:var1和var2确定当前值(地址+长度),var5为其先记录的当前值,当二者相同时,将自身替换为var5+var4(1)
while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
2
3
4
5
6
7
8
9
10
11
12
13
死锁(Dead Lock):比如ReentrantLock l锁l.lock()后忘记l.unlock()了,那么所有等待锁l的线程都会卡死,即为死锁
# 锁的实践
# Go 的并发和锁
只有单例才考虑本地锁,例如 daemon 服务,在线服务都得用 redis 锁,简单的事得想明白
go func 并发,TriggerBackupCron 触发 uid 对应的异步备份任务
- 提前生成本次 opTask uid 并立即返回,实际业务
inspect + rsync + callback在 goroutine 中异步执行 - goroutine 使用基于
goinfra.GlobalCtx派生的独立ctx,因为上游ctx在 HTTP Response 后将自动销毁,从而导致下游回调失败 - 返回的
opTaskUid由上游透传给调用方,稍后web-server会收到同一uid的/env/opTask/callback回调,由 goroutine 发起
func (its *CronTaskController) TriggerBackupCron(ctx tcontext.Context, uid string) (string, error) {
task := &models.BackupCronTask{}
// 从 LDB 里拿出任务
if err := base.GetV(models.BackupKey(uid), task); err != nil {
return "", fmt.Errorf("getBackupTaskFailed, uid:%s, err:%w", uid, err)
}
// 提前生成本次 fire 的 opTask uid(opTask-xxx),先返回给上游,再异步执行备份
opTaskUid := common.GetTaskUuidByPrefix(opTask.Prefix)
// 基于 goinfra.GlobalCtx 派生独立 ctx,与 HTTP 请求生命周期解耦;沿用原请求的 traceId 便于串联链路
asyncCtx := tcontext.WithContext(goinfra.GlobalCtx, ctx.Logger(), ctx.TraceId(), ctx.UserName())
// 异步执行:不能沿用请求 ctx(HTTP 返回后会被 cancel,导致 rsync 后的回调 context canceled)
go func() {
if err := runBackupOnce(asyncCtx, task, opTaskUid); err != nil {
asyncCtx.Logger().Errorf("triggerBackupCron async runBackupOnce failed, uid:%s, opTaskUid:%s, err:%v",
uid, opTaskUid, err)
}
}()
return opTaskUid, nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
go func 跑异步任务,一个主要的问题就是上下文 ctx 会丢失,外部 http 携带的 ctx 会随着 http response 销毁,销毁时异步任务还未结束......空的 ctx
- 这里折中的采用上游 ctx 派生一个有着同样信息的 ctx 下放,这个 ctx 只参与异步任务,不会随着 http response 销毁,以此串联异步任务和 http 请求的调用链路
- 但更通用且优雅的办法是用队列 workqueue 实现(参考 k8s client-go 的 workqueue)
Go sync.Map 本地锁,对 rsync 传输任务加锁,按照目录粒度给传输过程上锁,如果重复传输某一目录,将直接拒绝并返回 error
// rsyncLocks 以 srcDir 为粒度防并发,同一个目录上一次 rsync 未结束时直接跳过,不同目录互不阻塞
var rsyncLocks sync.Map // key: srcDir (string), value: *sync.Mutex
// DoRsyncPush 执行一次 rsync 同步,把 srcDir 内容推送到 targetNode 的 targetDir 目录
func DoRsyncPush(srcDir, targetNode, targetDir string) (string, error) {
if srcDir == "" || targetNode == "" || targetDir == "" {
return "", fmt.Errorf("doRsyncPush invalid args, upperDir:%q, targetNode:%q, targetDir:%q",
srcDir, targetNode, targetDir)
}
// 以 srcDir 为粒度加锁:同一目录上一次 rsync 未结束则跳过,不同目录并发互不影响
lock := &sync.Mutex{}
actual, loaded := rsyncLocks.LoadOrStore(srcDir, lock)
if loaded {
lock = actual.(*sync.Mutex)
}
if !lock.TryLock() {
return "", fmt.Errorf("doRsyncPush skipped, previous rsync still running for dir:%s", srcDir)
}
defer lock.Unlock()
// 源目录必须存在,否则 rsync 会报错,提前校验
if fi, err := os.Stat(srcDir); err != nil {
return "", fmt.Errorf("doRsyncPush stat srcDir failed, dir:%s, err:%w", srcDir, err)
} else if !fi.IsDir() {
return "", fmt.Errorf("doRsyncPush srcDir is not a directory, dir:%s", srcDir)
}
// 只传目录内容:src 末尾加 "/",rsync 语义为"传目录下的所有文件",避免把 upperDir 本身(diff)带过去
src := strings.TrimRight(srcDir, "/") + "/"
dest := fmt.Sprintf("rsync://%s@%s:%s/%s/%s/", config.Conf.RsyncConfig.User, targetNode,
config.Conf.RsyncConfig.Port, config.Conf.RsyncConfig.Module, strings.Trim(targetDir, "/"))
// -aHAX 完整保留容器可写层元数据:-a 归档(-rlptgoD),-H 硬链接,-A ACL,-X 扩展属性(xattr/capabilities)
// --delete 使目标与源保持一致(删除源已不存在的文件)
// --mkpath 自动创建目标端不存在的多级父目录(如 envId/backupUid 两级),需 rsync >= 3.2.3
cmd := exec.Command("rsync", "-aHAX", "--delete", "--mkpath", src, dest)
// 密码经 RSYNC_PASSWORD 环境变量注入,不落盘、不出现在命令行参数里
cmd.Env = append(os.Environ(), fmt.Sprintf("RSYNC_PASSWORD=%s", config.Conf.RsyncConfig.Secret))
out, err := cmd.CombinedOutput()
if err != nil {
return string(out), err
}
return string(out), 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
其实这里还有一种方案,就是对操作上锁,用一个信号量 + 维护一个 map 手动实现一个 ConcurrentHashMap
var (
mu sync.Mutex // 保护 tasks map
tasks = make(map[string]bool) // key: srcDir, value: true 表示正在执行
)
// DoRsyncPush 按源目录粒度加锁,同一时刻同一 srcDir 只允许一个 rsync 任务
func DoRsyncPush(ctx context.Context, srcDir, destDir string) (string, error) {
// 1. 加锁检查并标记任务
mu.Lock()
if _, exist := tasks[srcDir]; exist {
mu.Unlock()
return "", fmt.Errorf("rsync task for %s is already running", srcDir)
}
tasks[srcDir] = true
mu.Unlock() // 立即释放锁,避免阻塞其他目录的任务
// 2. 延迟清理标记(无论成功或失败都会执行)
defer func() {
mu.Lock()
delete(tasks, srcDir)
mu.Unlock()
}()
// 3. 执行 rsync 命令(不持有锁,允许其他目录并发执行)
cmd := exec.CommandContext(ctx, "rsync", "-avz", "--mkpath", srcDir, destDir)
output, err := cmd.CombinedOutput()
if err != nil {
return "", fmt.Errorf("rsync failed: %w, output: %s", err, string(output))
}
return string(output), 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
一般来讲,sync.Mutex + map[string][bool]写操作会快于原生的 sync.Map,后者是针对读多写少的场景优化的,读近乎无锁,而前者的读写更均衡
# Redis 分布式锁
通过 SET NX EX 实现分布式的悲观锁
utils/clients/redis.go
// RedisLock ...
func RedisLock(ctx tcontext.Context, client redis.Client, key string, timeout int) func() {
ret, err := client.Do(ctx, "SET", key, 1, "NX", "EX", timeout)
if err != nil {
ctx.Logger().Error("lock failed:", key, err.Error())
return nil
}
if ret == nil {
// lock failed
return nil
}
// lock ok
unlock := func() {
if _, err := client.Do(ctx, "del", key); err != nil {
ctx.Logger().Error("unlock failed:", key, err.Error())
}
}
return unlock
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
在业务层基于主键粒度对某一操作上锁,设置超时和重试实践
const (
EnvSshLockKeyFmt = "CODEV_ENV_SSH_LOCK_%s" // envId 粒度,下发/移除共用同一把锁
EnvSshLockExpire = 60 // 秒,锁自动释放兜底(覆盖最坏执行:paas 超时10s × 3次重试 + DB 操作)
EnvSshLockWaitSeconds = 15
)
// LockEnvSsh 以 envId 为粒度对 ssh 下发/移除加锁,等待至多 EnvSshLockWaitSeconds
func LockEnvSsh(ctx tcontext.Context, envId string) (func(), error) {
key := fmt.Sprintf(EnvSshLockKeyFmt, envId)
deadline := time.After(EnvSshLockWaitSeconds * time.Second)
for {
select {
case <-deadline:
return nil, goinfra.InvokeErrorCode.Newf("环境ssh操作进行中,请稍后重试, envId: %s", envId)
default:
if unlock := clients.RedisLock(ctx, config.RedisClientGlobal, key, EnvSshLockExpire); unlock != nil {
return unlock, nil
}
time.Sleep(300 * time.Millisecond)
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
真正的调用
func (its *collaboratorController) CreateCollaborator(ctx tcontext.Context, envId string){
// 对 enableSsh 操作上锁
unlock, err := LockEnvSsh(ctx, envId)
if err != nil {
return nil, err
}
// enableSsh 业务逻辑
}
2
3
4
5
6
7
8
又例如一个复杂的业务逻辑:任务执行后的状态回写
- 因为可能存在多个线程同时操作同一环境并进行回写,这里做一个必然的排斥,只有拿到锁才有回写的权限
- 并且,这里区分了操作来源,进行不同级别的上锁(被动回写的优先级大于主动回写),我理解是:被动回调是系统的内部处理,如果报错将是复杂流程中的一个 500 错误;而主动回写可能就是一个主动 HTTP 请求,报错了直接让用户重试就行
// UpdateStatus ...
func (envInstance *EnvInstanceController) UpdateStatus(ctx tcontext.Context, taskId, status, userName, source,
message string, code int) error {
// 主动处理任务需要加锁
if source == Source {
// 定时任务触发的主动回调,尝试获取锁,获取不到退出
if err := envInstance.HandleTaskLock(ctx, taskId); err != nil {
return err
}
} else {
// 加高优先级锁
if err := envInstance.HandleCallbackLock(ctx, taskId); err != nil {
return err
}
defer envInstance.HandleCallbackUnlock(ctx, taskId)
// 第三方被动回调,会不停尝试获取锁,直到超时
if err := envInstance.HandleTaskWaitingLock(ctx, taskId); err != nil {
return err
}
}
defer envInstance.HandleTaskUnlock(ctx, taskId)
// ...
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
这里的第三方被动回调去拿取任务锁,用了一个 5s 的自旋锁,将每隔 100 毫秒去尝试获取锁,印证了保证“被动回调”成功的重要性
// HandleTaskWaitingLock 获取任务回调update status锁,乐观锁,最多等5秒
func (envInstance *EnvInstanceController) HandleTaskWaitingLock(ctx tcontext.Context, taskId string) error {
timeoutChan := time.After(5 * time.Second)
for {
select {
case <-timeoutChan:
return goinfra.InvokeErrorCode.Newf("等待任务回调update status锁超时, taskId: %s", taskId)
default:
if err := envInstance.HandleTaskLock(ctx, taskId); err == nil {
return nil
}
time.Sleep(100 * time.Millisecond)
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
自旋锁本质上是悲观锁的变体,而不是乐观锁,xiyou 的注释有误
# Lua 原子锁
正常使用 Set NX EX 对前缀上锁
// lockUser 对用户加分布式锁,防止并发领取
// 返回 lockValue 用于后续释放锁
func (c *CCPoolController) lockUser(ctx tcontext.Context, username, poolId string) (string, error) {
key := fmt.Sprintf("%s%s:%s", ccPoolUserLockPrefix, username, poolId)
lockValue := fmt.Sprintf("%d-%s", time.Now().UnixNano(), common.GetTaskUuidByPrefix("lock"))
reply, err := config.Redis.Do(ctx, "SET", key, lockValue,
"NX", "EX", int(ccPoolLockTimeout.Seconds()))
if err != nil {
return "", fmt.Errorf("Redis SET命令失败: %w", err)
}
if reply == nil {
return "", nil // 加锁失败,已有任务在处理
}
return lockValue, nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
在解锁时,实现先比较再删除的 CAS,通过 Lua 脚本执行保证 Redis 的指令的原子性(事务)
// unlockUser 释放用户分布式锁(Lua脚本保证原子性)
func (c *CCPoolController) unlockUser(ctx tcontext.Context, username, poolId, lockValue string) {
key := fmt.Sprintf("%s%s:%s", ccPoolUserLockPrefix, username, poolId)
script := `
if redis.call("GET", KEYS[1]) == ARGV[1] then
return redis.call("DEL", KEYS[1])
else
return 0
end
`
if _, err := config.Redis.Do(ctx, "EVAL", script, 1, key, lockValue); err != nil {
ctx.Logger().Errorf("[CCPool] 释放用户锁失败, username=%s, poolId=%s, err=%v", username, poolId, err)
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
# 消息队列异步
在异步场景,消息队列的比重相当大,甚至在极端流量下,所有的 DB 写操作都会先经过 MQ 转发
- 文库所有的 SQL 都会经过一层 NMQ 转发
# RabbitMQ 基础
消息队列模型
- 点对点模型:又叫队列模型,每个生产者对应一个消费者(一对一)
- 订阅发布模型:一个生产者将把消息广播到每一个订阅者,即一对多模型,订阅发布能够将串行执行的任务变成“并行”,对于以下串行任务
它可以变成如下“并发”的形式,这是合理的,实际上,更新积分、通知商家、更新用户标签这三个事件并没有直接的逻辑联系或是执行顺序问题,他们都是由“更新订单状态触发”
- 不得不让人联想观察者模式,本质上是一样的,通过观察(订阅)事件驱动业务逻辑
安装和启动
yay -S rabbitmq rabbitmqadmin
sudo rabbitmq-plugins enable
sudo rabbitmq-server
2
3
后台运行:管理后台 15672,客户端 5672
rabbitmq-server -detached
Maven 依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
2
3
4
配置
spring:
rabbitmq:
host: 10.2.1.231
port: 5672
username: northboat
password: 123456
virtualHost: order
2
3
4
5
6
7
消费者示例,订阅队列 rabbitmq_queue
@Component
public class Consumer {
@RabbitHandler
@RabbitListener(queuesToDeclare = @Queue("rabbitmq_queue"))
public void process(String message) {
System.out.println("消费者消费消息: " + message);
}
}
2
3
4
5
6
7
8
生产者示例:生产字符串
@Component
public class Producer {
@Autowired
private RabbitTemplate rabbitTemplate;
public void produce() {
String message = new Date() + "Beijing";
System.out.println("生产者产生消息: " + message);
rabbitTemplate.convertAndSend("rabbitmq_queue", message);
}
}
2
3
4
5
6
7
8
9
10
11
我们尝试传输一个实体对象 User,需要进行序列化,继承Serializable类
public class User implements Serializable {
public String name;
public String password;
// 省略get和set方法
}
2
3
4
5
仍然通过convertAndSend方法进行传输,convertAndSend() 支持 String、Integer 等基础数据类型,传输 Object 对象需要实现序列化接口 Serializable
@Component
public class Producer {
@Autowired
private RabbitTemplate rabbitTemplate;
public void produce() {
User user = new User("nmsl", "wdnmd");
System.out.println("生产者生产消息: " + user);
rabbitTemplate.convertAndSend("rabbitmq_queue_object", user);
}
}
2
3
4
5
6
7
8
9
10
11
12
RabbitMQ 交换机:定义 MQ 队列的传输类型,一对一 or 一对多
| 交换机 | 匹配规则 | 场景 |
|---|---|---|
| Direct | 路由键与绑定键完全相等 | 精准路由、任务分发 |
| Fanout | 忽略路由键,广播到所有绑定队列 | 发布订阅、消息广播 |
| Topic | 路由键与绑定键支持通配符(*匹配一个词,#匹配多个词) | 模糊匹配、分类路由 |
| Headers | 基于消息头属性匹配,不依赖路由键 | 复杂属性匹配(极少使用) |
RabbitMQ 三大队列
- Classic:基础队列
- Quorum:部分是一致性仲裁队列
- Stream:流式日志队列
# 可靠传输和一致性
在使用消息队列时,因为生产者和消费者不直接交互,所以面临下面几个问题
- 要把消息添加到队列中,怎么保证消息成功添加?
- 如何保证消息发送出去时一定会被消费者正常消费?
- 消费者正常消费了,生产者或者队列如何知道消费者已经成功消费了消息?
如何保证消息 100% 可靠性发送?可以采用 ack 应答 + 日志记录 + 定时任务来实现
假设有一个创建订单业务,后端收到请求后,将该业务通过消息队列发送到具体的业务模块,我们这样保证消息的可靠传输
- 完成订单业务处理后,生产者发送一条消息到消息队列,同时记录这条操作日志(发送中)
- 消费者收到消息后处理进行
- 消费者处理成功后给消息队列发送 ack 应答
- 消息队列收到 ack 应答后,给生成者的 Confirm Listener 发送确认
- 生产者对消息日志表进行操作,修改之前的日志状态(发送成功)
- 在消费端返回应答的过程中,可能发生网络异常,导致生产者未收到应答消息,因此需要一个定时任务去提取其状态为“发送中”并已经超时的消息集合
- 使用定时任务判断为消息事先设置的最大重发次数,大于最大重发次数就判断消息发送失败,更新日志记录状态为发送失败
如何在分布式环境下保证消息队列中的消息按顺序消费?在单片 Topic 中,每个消息将按照他进入消息队列的顺序被依次消费,但很多时候 Topic 不止一个,我们该如何保证每个消息的顺序执行呢
- 我们只关心特定的操作顺序,在粗粒度下进行单 Topic 的传输,例如对于一次个订单,下单、付款、发货三个操作必须按照顺序执行,那么他们必须存在同一个 Topic 下,但对于其他订单并不产生影响,所以我只需要考虑将需要按照顺序执行的消息存放在同一个 Topic 就行
# Kafka 和 RabbitMQ
Kafka、RabbitMQ 和 Pulsar
在日志处理上为什么 Kafka 比 RabbitMQ 权威?为什么 Kafka 更适合批处理?
Kafka 的核心结构是 Append-only log,他的写入是从缓存到磁盘再到缓存,并且“永远只追加、顺序写、批量写”
Producer → PageCache → Disk → PageCache → Consumer
在写的过程中,Kafka 实际是在用操作系统的磁盘 I/O 当作 Socket 网络缓冲区,在这,Kafka 用到了一个关键的技术:Zero Copy + mmap(某传奇 Web 服务器表示赞同)
- 顺序读写 + mmap(Memory Map 内存映射):使用 linux 内核提供的 api,mmap 将磁盘文件映射到内存,支持读写,对内存的操作就会反映在磁盘文件上,但这不是实时写入磁盘的,操作系统会在程序主动调用 flush 的时候才真正的把数据写到硬盘,实现的批量写入
- 零拷贝:使用 linux 内核提供的 sendfile api,sendfile 是将读到内核空间的数据直接发送到 socket buffer,这是一个直接的网络发送
- 用通信实现内存共享,而不是使用内存共享来通信 → 零拷贝
而对应的 RabbitMQ 写入模型为 AMQP(Advanced Message Queue Protocol),这是 CPU + 内存驱动的架构
- 发布者(Publisher)发布消息(Message),经由交换机(Exchange)
- 交换机根据路由规则将收到的消息分发给与该交换机绑定的队列(Queue)
- 最后 AMQP 代理会将消息投递给订阅了此队列的消费者,或者消费者按照需求自行获取
在 RabbitMQ 中,每次消息分发到指定队列,都是对原来的消息的一次逻辑复制
- 什么叫“逻辑复制”?就是说,每次复制,消息体复制一份指针指向共享内存,但由于需要状态管理,在每个队列中,都必须有自己的 offset、ack 状态、重试、TTL、死信等信息,这些信息都是需要复制一份的
- AMQP 的每条消息都要经过这样几个步骤:“解析协议,路由 → 复制到队列 → 做 ACK,做状态维护”
Kafka 吞吐显著大于 RabbitMQ
- 从消息传递方式考虑,RabbitMQ 要分发要复制,Kafka 是直接把磁盘作为 Socket 网络缓存,采用零拷贝和系统 mmap 接口,更直接、更快
- 从硬件资源考虑,Kafka 用磁盘缓冲,量级远大于 RabbitMQ 用内存缓冲
- 从任务的复杂度考虑,Kafka 不需要维护消息状态,不需要 ack 相应,这使得他对消息的处理更加简单
但相应的:由于 CPU + 内存的处理速度远大于 CPU + I/O,故而 RabbitMQ 的响应速度远大于 Kafka,并且由于 RabbitMQ 的确认机制,使之更适合做功能解耦的业务场景
- Kafka 是“重消费者模型”,一个消费者干大量的活,但不支持连接过多的消费者
- RabbitMQ 的 Channel 是“轻量级虚拟连接”,支持连接大量的消费者,但每个消费者的吞吐较慢
一句话说:Kafka 是重卡,RabbitMQ 是摩托车队