跳到主要内容
约 10 分钟4 张卡

线程同步

线程同步是用约定好的规则协调共享数据访问和执行顺序,让多个线程交错运行时仍能得到正确结果。互斥锁防止操作相互穿插,条件变量让线程等待条件变化,信号量记录还剩多少许可。理解它们的用途,比记住 API 名字更重要:要能说明哪些操作必须一起完成、线程为什么等待,以及唤醒后还要检查什么。

1. 面试核心​

先记住这几条,再读正文
  • 读改写操作需要作为一个整体受保护,只保证独立读取和写入,仍可能丢失更新。
  • 为维护同一个共享不变量,读者和写者都要遵守同一套同步规则,避免观察到修改一半的状态。
  • 条件变量的 wait 会原子释放锁并等待,返回前重新获取锁;唤醒后仍要循环检查条件。卡 · 面试核心
  • 有界队列要分别等待非空与未满;关闭时唤醒两类等待者,并约定已经入队的任务是否继续处理。卡 · 有界阻塞队列与关闭
  • 条件变量不保存无人接收的通知,信号量会保存许可计数,二者不能互相套用。卡 · 条件变量

2. 临界区与共享不变量​

临界区是访问共享状态、需要协调执行的代码区域。共享不变量是这些操作必须共同维护的条件,例如余额要包含每一次已经完成的加款。

余额初始为 100,两个线程各加 10。如果两个线程都先读到 100,再分别算出并写回 110,最终就少了一次更新。问题在于「读取、计算、写回」没有作为一个整体受保护。

用互斥锁保护完整的临界区后,同一时刻只有一个线程执行这组操作,另一个线程随后读到的就是更新后的余额。单个计数器也可以用原子读改写操作;涉及多个变量时,则要让整组修改共同满足约束。

比如转账要同时修改两个账户,读者也要遵守同一套同步规则,否则可能读到一个账户已经扣款、另一个还没入账的中间状态。只给写入加锁,而让读者随意访问,并没有完整保护这份共享状态。

3. 条件变量​

条件变量让线程在条件尚未满足时释放锁、进入等待,等条件可能发生变化后再继续检查。例如消费者要等队列非空,伪代码如下:

lock(mutex)
while queue is empty:
wait(notEmpty, mutex)
item = queue.removeFirst()
unlock(mutex)

wait(notEmpty, mutex) 把释放 mutex 和进入等待作为一个原子步骤,返回前会重新取得 mutex。消费者等待时不占着锁,生产者才能按同一互斥规则把元素放进队列,再通知等待者。

消费者必须用 while 再次检查 queue is empty。一方面,虚假唤醒可能让线程在没有对应通知时从等待中返回;另一方面,即使有生产者入队,其他消费者也可能先取得锁并拿走元素。因此,唤醒只表示可以重新检查,不保证队列里一定还有东西。这里被检查的条件也叫谓词。

有等待者时,signal 至少唤醒一个,broadcast 唤醒全部,但被唤醒的线程仍要竞争 mutex。如果通知时没有等待者,这次通知不会保存下来。真正决定消费者能否取元素的,是持锁检查到的队列状态。

3.1 有界阻塞队列与关闭​

有界阻塞队列在容量固定的前提下,让生产者在满时等待、消费者在空时等待。两类等待者的条件不同:消费者等待 notEmpty,生产者等待 notFull,但它们检查和修改的是同一份队列状态,必须共用一把锁。

下面用 Go 1.22 展示条件变量协议。这是参考实现的语言选择,不要求所有线程同步题都用 Go 回答。环形存储沿用并发队列的加锁基线,这里增加等待与关闭,不另讨论无锁算法。将代码保存为 queue.go:

package main

import "sync"

type BoundedQueue struct {
mu sync.Mutex
notEmpty, notFull *sync.Cond
data []int
head, size int
closed bool
}

func NewBoundedQueue(capacity int) *BoundedQueue {
if capacity <= 0 {
panic("capacity must be positive")
}
q := &BoundedQueue{data: make([]int, capacity)}
q.notEmpty = sync.NewCond(&q.mu)
q.notFull = sync.NewCond(&q.mu)
return q
}

// 调用者已持有 q.mu,且队列未满、未关闭。
func (q *BoundedQueue) push(value int) {
q.data[(q.head+q.size)%len(q.data)] = value
q.size++
q.notEmpty.Signal()
}

func (q *BoundedQueue) Put(value int) bool {
q.mu.Lock()
defer q.mu.Unlock()
for q.size == len(q.data) && !q.closed {
q.notFull.Wait()
}
if q.closed {
return false
}
q.push(value)
return true
}

func (q *BoundedQueue) TryPut(value int) bool {
q.mu.Lock()
defer q.mu.Unlock()
if q.closed || q.size == len(q.data) {
return false
}
q.push(value)
return true
}

func (q *BoundedQueue) Take() (int, bool) {
q.mu.Lock()
defer q.mu.Unlock()
for q.size == 0 && !q.closed {
q.notEmpty.Wait()
}
if q.size == 0 {
return 0, false
}
value := q.data[q.head]
q.data[q.head] = 0
q.head = (q.head + 1) % len(q.data)
q.size--
q.notFull.Signal()
return value, true
}

func (q *BoundedQueue) Close() {
q.mu.Lock()
defer q.mu.Unlock()
q.closed = true
q.notEmpty.Broadcast()
q.notFull.Broadcast()
}

Put 等待可用槽位,Take 等待元素;TryPut 在满时直接返回 false,但仍可能等待获取互斥锁,不能称为无锁操作。三个方法都在同一个临界区内检查条件并改变状态,保证 size 不超过容量、每个元素只被一个消费者取走。布尔返回值区分失败与数值 0,不能把零值当作队空。

Put 成功后通知消费者,Take 成功后通知生产者。把两类等待者混在一个条件变量上却只用 Signal,可能叫醒条件仍不成立的一方,让真正能推进的另一方继续等待。分开通知目标,才能让通知与改变的条件对应。

关闭约定是:不再接收新元素,已接收的元素继续取出,关闭且排空才结束消费。Close 必须广播两个条件变量,否则等空间的生产者或等任务的消费者可能一直睡下去。关闭与入队竞争时,谁先在锁内生效就决定该元素是否被接收;重复关闭允许发生。正常结束应先等所有生产者提交完,再关闭,然后等消费者退出。

Go 的 Cond.Wait 不会像某些平台的条件变量那样无通知返回,但仍必须用循环:被通知后,其他消费者可能先拿走元素;广播也不保证每个人都有可用资源。队列必须通过构造函数创建并共享指针,使用后不能复制含锁的对象。这个最小实现没有单次操作超时、取消或公平性保证;需要这些能力时,必须把退出状态与唤醒安排纳入同一协议,不能在外面放一个计时器就认为等待已取消。

3.2 有限座位与银行叫号​

银行叫号可以用同一队列表达:前台接收顾客,窗口从队列领取号码。先把题目条件说清楚:5 个窗口,每个顾客服务 5 秒,每秒到达一个顾客,大厅有 25 个等候座位。这里约定座位只计算等待者,不包含正在窗口办理的人;满时顾客本次不取号,也不在程序内继续等座位。若面试官把座位定义为大厅总人数,就要另外计算办理中的人数。

满时“不再放号”对应 TryPut,不能换成会等待的 Put。由单个前台按顺序发号,只有入队成功才推进号码;窗口取号后就释放等候座位。办理和休眠必须在队列锁外,否则一个窗口会把其他窗口也挡住。下面的 bank.go 与前面的 queue.go 放在同一目录,通过 go run queue.go bank.go 运行:

package main

import (
"fmt"
"sync"
"time"
)

func runBank(total, seats, windows int, arrival, service time.Duration) (accepted, rejected int, finished []int) {
if total < 0 || windows <= 0 || arrival < 0 || service < 0 {
panic("invalid bank configuration")
}
q := NewBoundedQueue(seats)
var workers sync.WaitGroup
var resultMu sync.Mutex
for w := 0; w < windows; w++ {
workers.Add(1)
go func() {
defer workers.Done()
for {
ticket, ok := q.Take()
if !ok {
return
}
time.Sleep(service)
resultMu.Lock()
finished = append(finished, ticket)
resultMu.Unlock()
}
}()
}
for customer := 0; customer < total; customer++ {
if customer > 0 {
time.Sleep(arrival)
}
if q.TryPut(accepted + 1) {
accepted++
} else {
rejected++
}
}
q.Close()
workers.Wait()
return
}

func main() {
// 演示把题目中的 1 秒缩为 10 毫秒,保留 1:5 的时间比例。
accepted, rejected, finished := runBank(40, 25, 5, 10*time.Millisecond, 50*time.Millisecond)
fmt.Printf("accepted=%d rejected=%d finished=%d\n", accepted, rejected, len(finished))
}

为了让模拟能够结束,total 明确限定本次到达人数;原题没有给出的营业时长,也可以改用一个明确的停止到达信号。发完本次所有号码后,前台关闭队列,窗口处理完已经接收的顾客再退出,主 goroutine 用 WaitGroup 等它们结束。服务完成记录有单独的锁保护,不会占着队列锁办理业务。

输出满足 accepted + rejected == total,且 len(finished) == accepted。完成的号码恰好是 1 到 accepted,但多个窗口的完成顺序可能不同,不能把完成日志顺序当作叫号顺序。比如只接收了号码 1、2,两个窗口都已取走,2 先完成也没有破坏队列 FIFO。

main 把 1 秒缩成 10 毫秒,把 5 秒缩成 50 毫秒;恢复题目的时间单位只需改这两个参数。操作系统调度和 Sleep 不提供精确的实时到达保证,输出也不能用来证明长期吞吐或等待时间。验证满座时应单独制造突发到达或暂停办理,不能因一次均匀到达没有拒绝顾客,就认为满座分支已经验证过。

4. 信号量与许可​

信号量保存可用许可的计数:sem_wait 取得一份许可,计数为 0 时等待;sem_post 增加一份许可,也可以由另一个线程调用。与条件变量不同,即使当时没有等待者,增加的许可也会保留下来。

例如最多允许 8 个任务同时执行,可以把信号量初值设为 8。每个任务先取得许可,结束时归还,异常退出路径也要归还。它限制的是并发数量:这 8 个任务如果共同修改同一个对象,仍需另行保护对象状态。

POSIX 互斥锁要求由持有它的线程解锁;信号量表达资源数量或通知计数,可以由不同线程增减许可。其他语言或运行库对锁的持有者可能有不同约定,使用时需要核对具体 API。保护一段共享状态和限制同时工作的任务数,是两种不同需求。

5. 自旋与阻塞等待​

自旋等待是线程不断检查锁状态,不主动休眠。持锁时间很短、持有者又正在运行时,等一小会儿可能就能取得锁,省去休眠和唤醒的调度成本。但临界区很长,或者持有者已经被抢占,自旋线程就只是在消耗 CPU。

阻塞等待让线程休眠,等资源可用时再唤醒,节省等待期间的 CPU,代价是调度开销。读多写少且临界区足够长时,也可以评估读写锁,让读操作共享访问,但要同时检查其公平性策略是否让写者等待过久。

6. 使用边界​

同步既要安排执行顺序,也要保证一个线程的修改按规则对另一个线程可见。C/C++ 的 volatile 本身不提供线程同步,不能代替锁或原子操作;具体应使用哪种机制,要遵守对应语言的内存模型。

持锁执行慢网络调用会扩大临界区等待。锁顺序和失败释放策略见死锁。

7. 面试题卡片​

8. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明