锁的抽象层与陷阱
一、盘点:五套锁并存是什么样子
打开一个运行了几年、融合了自研代码 + 开源框架 + 第三方库的嵌入式工程,锁通常是这样的:
| 族 | 代表 API | 谁产生的 | 能否在中断里用 | 与其他族是否互通 |
|---|---|---|---|---|
| 内核互斥量 | mutex_take / mutex_release | RTOS 原生 | 否(会睡眠) | 否 |
| 内核信号量/事件 | sem_take / sem_release、event_send | RTOS 原生 | 仅 release/send | 否 |
| POSIX 锁 | pthread_mutex_lock | 移植的框架层、开源库 | 否 | 否 |
| C++ 标准库 | std::mutex + std::lock_guard | C++ 模块 | 否 | 否(对象类型不同) |
| 调度器锁 | sched_lock / sched_unlock(关调度) | 自研临界区 | 是 | —(不是对象) |
| 关中断 | irq_disable / irq_enable | 自研临界区 | 是 | —(不是对象) |
| 适配层 | LOS_MuxPend / LOS_MuxPost | 开源框架 API 在本工程上的实现 | 否 | 取决于映射目标 |
| 原子操作 | atomic_load / atomic_exchange | 状态标志 | 是 | — |
关键事实:这些锁互相之间完全不知道对方存在。用 A 族锁保护的资源,B 族锁的持有者可以直接闯进去。
二、为什么会长成五套(这是历史,不是失误)
不要一上来就把它定义成"技术债"。五套锁的成因通常是合理的:
时间线
─────────────────────────────────────────────
阶段1 自研业务代码 → 内核互斥量、调度器锁
阶段2 引入开源框架 → 框架自带 POSIX 锁
阶段3 引入 C++ 模块 → std::mutex(RAII 习惯)
阶段4 框架适配层 → 把框架 API 翻译成本内核 API
阶段5 第三方库 → 各自带锁
阶段6 性能优化点 → 少量原子操作
每一步在当时都是正确决策。问题不在"引入",而在引入时没有人负责"统一语义"。
适配层:API 能翻译,语义未必能翻译
典型实现长这样:
/* 适配层:把上层框架的互斥量 API 映射到本内核 */
int LOS_MuxPend(uint32_t muxId, uint32_t timeout)
{
mutex_t *m = handle_to_mutex(muxId);
return (mutex_take(m, to_ticks(timeout)) == OK) ? 0 : -1;
}
int LOS_MuxPost(uint32_t muxId)
{
mutex_t *m = handle_to_mutex(muxId);
mutex_release(m);
return 0;
}
代码只有十几行,看起来天衣无缝。但"翻译函数签名"和"翻译语义"是两件事:
| 语义维度 | 上层框架的期望 | 本内核的实际行为 | 后果 |
|---|---|---|---|
| 超时单位 | 毫秒 | tick(可能是 10ms 粒度) | 1ms 超时被换算成 0 tick → 变成非阻塞尝试 |
| 等待策略 | 优先级排序 | 默认 FIFO | 高优先级任务排队靠后 |
| 优先级继承 | 有(框架文档这么写) | 取决于创建属性,可能没有 | 高优先级任务被饿死 |
| 可重入性 | 非递归 | 非递归(一致) | 一般无问题,但上层若重入就死锁 |
| 错误码 | 0 / -1 | 0 / 特定负值 / 正数错误码 | 上层判断 != 0 时误判 |
| 中断上下文 | 不允许 | 不允许 | 一致,但断言可能被关闭 |
这张表是第三篇的核心:你认为自己"用了框架的锁",实际上你用的是"一个语义不完全一致的替身"。
三、三个必踩的坑
坑一:两把锁保护同一份数据 = 没有保护
这是五套锁并存最隐蔽的后果。
/* 模块 A:用 POSIX 锁保护配置表 */
static pthread_mutex_t g_cfg_lock;
void cfg_set_from_a(int v)
{
pthread_mutex_lock(&g_cfg_lock);
g_cfg = v;
pthread_mutex_unlock(&g_cfg_lock);
}
/* 模块 B:用内核互斥量保护"同一份"配置表 */
static mutex_t g_cfg_mutex;
void cfg_set_from_b(int v)
{
mutex_take(&g_cfg_mutex, WAIT_FOREVER);
g_cfg = v;
mutex_release(&g_cfg_mutex);
}
两个函数各自都正确地加了锁,代码评审时逐行看都没问题。但两个线程同时调用时,g_cfg = v依然可能丢更新——因为两把锁排斥的是不同的对象。
为什么难发现:
| 因素 | 说明 |
|---|---|
| 评审按文件看 | 每个人只看自己那半边,两把锁从不出现在同一个文件里 |
| 变量名不同 | g_cfg_lock 和 g_cfg_mutex,看名字看不出是同一份数据 |
| 现象偶发 | 只有并发写时才出错,且不一定每次都错 |
防御手段:给共享数据建"归属表"——每份需要保护的共享数据,必须在文档里写明"由哪把锁保护"。没有归属表的项目,一定会出现这个坑。
坑二:上下文用错,直接崩或偶发卡死
错误一:中断里拿会睡眠的锁
/* 串口中断服务程序 */
void uart_isr(void)
{
mutex_take(&g_uart_lock, WAIT_FOREVER); /* 错:中断上下文不能阻塞 */
ring_push(&g_rx_ring, byte);
mutex_release(&g_uart_lock);
}
后果分三种,取决于内核实现和断言开关:
| 情况 | 表现 |
|---|---|
| 断言开启 | 立即触发断言,定位容易(幸运) |
| 断言关闭、拿锁成功 | 看起来正常,但破坏了内核调度状态机,埋雷 |
| 断言关闭、需要等待 | 中断上下文无法被调度,直接卡死 |
正确写法:ISR 只做"投递",处理放任务里。
void uart_isr(void)
{
ring_push_lockfree(&g_rx_ring, byte); /* 单生产者单消费者,无锁 */
sem_release(&g_rx_sem); /* 仅唤醒,不阻塞 */
}
void uart_task(void *arg)
{
for (;;) {
sem_take(&g_rx_sem, WAIT_FOREVER);
process_rx();
}
}
错误二:关中断期间做重活
level = irq_disable();
log_printf("event=%d", e); /* 错:日志内部可能加锁、可能阻塞、可能很慢 */
data = malloc(size); /* 错:内存分配有锁 */
irq_enable(level);
后果:全局中断延迟被拉长。原本 2µs 的关中断变成 2ms,所有中断响应全部延后,实时性崩坏,且现象表现为"别的模块偶发丢数据"——排查方向完全被带偏。
规则:关中断区间内只允许"内存读写 + 算术运算",不允许函数调用(尤其是日志、内存分配、IO)。
坑三:语义泄漏——以为 1ms 就是 1ms
/* 上层:期望最多等 1ms */
ret = LOS_MuxPend(mux, 1); /* 1 毫秒 */
/* 适配层:直接换算 */
mutex_take(m, timeout / TICK_MS); /* 向下取整:1 / 10 = 0 */
/* 内核:0 表示"不等待,立即返回" */
结果:上层以为"最多等 1ms",实际行为是"尝试一次,失败就走"。功能上可能"看起来能用"(因为大多数时候锁是空闲的),但一旦有争抢,上层逻辑就完全失效。
正确的换算应该向上取整,并保证最小 1 tick:
static inline uint32_t to_ticks(uint32_t ms)
{
uint32_t t = (ms + TICK_MS - 1) / TICK_MS; /* 向上取整 */
return (t == 0) ? 1 : t; /* 至少等 1 tick */
}
推广:所有"单位换算"处都要问一句——取整方向错了会变成什么语义? 超时、延迟、周期、看门狗时间,都是同一类问题。
四、三个真实缺陷模式(匿名案例)
以下三种模式在长期演进的嵌入式工程里出现频率极高,值得逐个对照检查。
缺陷一:单例锁"声明了但没初始化"
/* 典型写法:单例类里放一把静态锁 */
class ObserverMgr {
public:
static ObserverMgr &Instance()
{
mutex_take(s_lock, WAIT_FOREVER); /* 直接对静态成员加锁 */
if (s_instance == nullptr) {
s_instance = new ObserverMgr();
}
mutex_release(s_lock);
return *s_instance;
}
private:
static mutex_t s_lock; /* 只声明 */
static ObserverMgr *s_instance;
};
mutex_t ObserverMgr::s_lock; /* 定义:零初始化 = NULL */
问题:全工程找不到这把锁的 create/init。静态存储期对象零初始化,s_lock 的值就是 NULL,而 mutex_take(NULL, ...) 的行为是:
| 编译配置 | 结果 |
|---|---|
| 断言开启 | 立即断言失败(在首次调用 Instance() 时) |
| 断言关闭 | 解引用空指针 → 访问非法地址 → 硬件异常或静默踩内存 |
三种正确写法:
/* 方案 A:静态初始化宏(首选,零运行时开销) */
static mutex_t s_lock = MUTEX_STATIC_INIT;
/* 方案 B:启动阶段一次性初始化(此时只有一个线程) */
void app_early_init(void)
{
s_lock = mutex_create("observer");
}
/* 方案 C:必须延迟初始化 → 用平台的一次性初始化原语 */
static once_t s_once = ONCE_INIT;
void ensure_lock(void)
{
once_run(&s_once, create_lock_thunk, NULL);
}
一个附带的知识点:即使把 s_lock 初始化了,上面那段 Instance()仍然是双重检查锁定的错误版本——它在锁外读 s_instance,而 new ObserverMgr() 的"分配 + 构造 + 发布"三步可能被重排。单核上的正确做法是:启动阶段单线程建好单例,或用原子指针发布。延迟初始化这种事,能不做就不做。
缺陷二:锁"创建了但从未使用"
static mutex_t g_parser_mutex;
void parser_init(void)
{
g_parser_mutex = mutex_create("parser", PRIO); /* 创建 */
}
/* ……全文再无任何 mutex_take(g_parser_mutex) / release */
三种可能,都需要处理:
| 可能 | 判断方法 | 处理 |
|---|---|---|
| 漏加锁(重构时把 take/release 删了) | 看数据是否被多线程访问 | 补上,并加注释说明保护什么 |
| 死代码(锁被废弃但没删) | 看数据是否已改为单线程访问 | 删掉,避免误导 |
| 保护对象不存在(当年为了"以后要用"预留) | 看有无 TODO | 删掉,YAGNI |
为什么"有锁不用"比"没锁"更危险:
它给人虚假的安全感。后续维护者看到这把锁,会认为"这块数据已经有保护了",于是放心地在别的线程里访问——问题被埋得更深。
发现手段:写个简单脚本,统计"创建过的锁"与"实际 take 次数",出现 0 次就人工核对。这类静态检查在代码量上万行时非常划算。
缺陷三:同一个 RAII 封装被重造三次
/* A 模块 */
class ScopedLockA {
public:
explicit ScopedLockA(pthread_mutex_t &m) : m_(m) { pthread_mutex_lock(&m_); }
~ScopedLockA() { pthread_mutex_unlock(&m_); }
private:
pthread_mutex_t &m_;
};
/* B 模块(另一个团队写的) */
class ScopedLockB {
public:
explicit ScopedLockB(pthread_mutex_t *m) : m_(m) { pthread_mutex_lock(m_); }
~ScopedLockB() { pthread_mutex_unlock(m_); }
private:
pthread_mutex_t *m_;
};
/* C 模块(第三次) */
class MutexGuard {
public:
explicit MutexGuard(mutex_t m) : m_(m) { mutex_take(m_, WAIT_FOREVER); }
~MutexGuard() { mutex_release(m_); }
bool IsLocked() const { return locked_; }
private:
mutex_t m_;
bool locked_;
};
三个类功能相同,参数形式不同(引用/指针/句柄),语义细节还略有差异(第三个底层是内核锁)。
代价:
| 代价 | 说明 |
|---|---|
| 迁移成本 | 换锁机制时要改三处,且三处的边界条件不同 |
| 认知成本 | 新人不知道该用哪个,通常会再写第四个 |
| 一致性风险 | 某一个实现了 IsLocked(),另外两个没有,代码里就出现了"只有部分地方能做检查" |
| 统计盲区 | 想加锁统计时,要改三个类 |
这不只是"重复代码"问题,而是"抽象缺失导致团队各自发明轮子"的典型。解决方法在下一节。
五、收敛:一个薄抽象层
目标不是"消灭五套锁"(那不现实),而是让上层只看见一套,且语义明确。
设计目标
| 目标 | 说明 |
|---|---|
| 语义归一 | 超时统一用毫秒(内部换算),等待策略显式指定,是否继承显式声明 |
| 上下文断言 | 在中断里调用睡眠锁,立即报错而不是埋雷 |
| 统计钩子 | 争抢率、最大持有、最大等待,一处埋点全局可见 |
| 调试信息 | 记录持有者、持有时长、文件行号 |
伪代码实现
/* 统一锁对象 */
typedef struct lock {
void *impl; /* 底层实现:mutex / pthread / sem ... */
uint8_t kind; /* LOCK_MUTEX / LOCK_SEM / LOCK_IRQ ... */
const char *name;
#ifdef LOCK_DEBUG
task_t *owner;
uint64_t held_since;
const char *file;
int line;
lock_stat_t stat;
#endif
} lock_t;
int lock_init(lock_t *l, uint8_t kind, const char *name);
int lock_acquire(lock_t *l, uint32_t timeout_ms); /* 统一毫秒 */
void lock_release(lock_t *l);
/* 作用域宏:离开作用域自动释放 */
#define LOCK_SCOPE(l) \
for (int _once = (lock_acquire((l), LOCK_WAIT_FOREVER), 1); _once; \
_once = (lock_release((l)), 0))
关键:上下文断言
int lock_acquire(lock_t *l, uint32_t timeout_ms)
{
/* 睡眠锁不允许在中断上下文使用 */
if (l->kind == LOCK_MUTEX) {
ASSERT_NOT_IN_ISR(); /* 断言开启时立即暴露,关闭时降级为告警 */
}
/* 不允许在关中断区间内睡眠 */
ASSERT_IRQ_ENABLED();
#ifdef LOCK_DEBUG
l->file = __FILE__;
l->line = __LINE__;
#endif
uint32_t ticks = to_ticks_ceil(timeout_ms); /* 统一向上取整 */
int rc = mutex_take((mutex_t *)l->impl, ticks);
#ifdef LOCK_DEBUG
if (rc == OK) {
l->owner = task_self();
l->held_since = now_us();
stat_on_take(&l->stat, ...);
}
#endif
return rc;
}
这三件事(单位归一、上下文断言、调试埋点)如果在一个工程里统一做好,前面提到的坑会消失一大半。
迁移策略(不要一次全改)
| 阶段 | 动作 |
|---|---|
| 第 1 步 | 新代码强制使用 lock_t,评审卡这一条 |
| 第 2 步 | 每个模块按"改动频率"排序,从最常改的模块开始替换 |
| 第 3 步 | 在旧锁上挂告警(如创建时打印"old API used"),逐步清零 |
| 第 4 步 | 用统计数据证明收益(争抢率、最大等待改善),推动剩余模块 |
切忌"一次性大重构":锁的改动最容易引入偶发问题,而偶发问题最难验证。
六、代码评审清单(可直接贴进团队规范)
- 锁对象是否已初始化?(静态初始化 / 显式 create 且只创建一次)
- 这把锁保护的是哪份数据?能否在"数据归属表"里查到?
- 是否可能在中断上下文调用?(睡眠锁禁止)
- 是否在关中断区间内调用了可能阻塞的函数?(日志、分配、IO)
- 持锁期间是否做了耗时操作?(遍历、计算、序列化)
- 多锁场景:获取顺序是否全局一致?
- 是否有超时?超时后的动作是什么?(降级/上报/自愈,而不是盲重试)
- 是否用二值信号量替代了互斥量?(无优先级继承)
- 递归锁是否必要?(多数情况是设计问题)
- 这把锁是否被统计覆盖?(争抢率、最大持有、最大等待)
七、工具化:把纪律变成自动化
人工评审会疲劳,能自动化的都要自动化。
| 手段 | 实现思路 | 能发现什么 |
|---|---|---|
| 静态扫描 | 正则/AST 检查 create 无 take、take 无 release、irq_disable 区间内出现函数调用 | 缺陷一、缺陷二、坑二 |
| 运行时统计 | 统一锁封装内的 lock_stat_t | 争抢率、最大等待、最大持有 |
| 持有者记录 | 调试版记录 owner + 时间 + 文件行号 | 超时定位、反转排查 |
| 锁顺序检查 | 记录"当前任务持有栈",发现逆序获取时告警 | 死锁预防 |
| 长持有告警 | hold_max 超阈值时打印调用栈 | 大锁、临界区过长 |
其中"锁顺序检查"的收益特别高:它能在死锁发生之前就发现"有人在用相反的顺序加锁"。实现不复杂——每个任务维护一个已持有锁的栈,加锁时检查新锁是否在栈中且顺序更靠前。
更多推荐
所有评论(0)