一、盘点:五套锁并存是什么样子

打开一个运行了几年、融合了自研代码 + 开源框架 + 第三方库的嵌入式工程,锁通常是这样的:

族代表 API谁产生的能否在中断里用与其他族是否互通
内核互斥量mutex_take / mutex_releaseRTOS 原生否(会睡眠)否
内核信号量/事件sem_take / sem_release、event_sendRTOS 原生仅 release/send否
POSIX 锁pthread_mutex_lock移植的框架层、开源库否否
C++ 标准库std::mutex + std::lock_guardC++ 模块否否(对象类型不同)
调度器锁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 / -10 / 特定负值 / 正数错误码上层判断 != 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 步用统计数据证明收益(争抢率、最大等待改善),推动剩余模块

切忌"一次性大重构":锁的改动最容易引入偶发问题,而偶发问题最难验证。


六、代码评审清单(可直接贴进团队规范)

  1. 锁对象是否已初始化?(静态初始化 / 显式 create 且只创建一次)
  2. 这把锁保护的是哪份数据?能否在"数据归属表"里查到?
  3. 是否可能在中断上下文调用?(睡眠锁禁止)
  4. 是否在关中断区间内调用了可能阻塞的函数?(日志、分配、IO)
  5. 持锁期间是否做了耗时操作?(遍历、计算、序列化)
  6. 多锁场景:获取顺序是否全局一致?
  7. 是否有超时?超时后的动作是什么?(降级/上报/自愈,而不是盲重试)
  8. 是否用二值信号量替代了互斥量?(无优先级继承)
  9. 递归锁是否必要?(多数情况是设计问题)
  10. 这把锁是否被统计覆盖?(争抢率、最大持有、最大等待)

七、工具化:把纪律变成自动化

人工评审会疲劳,能自动化的都要自动化。

手段实现思路能发现什么
静态扫描正则/AST 检查 create 无 take、take 无 release、irq_disable 区间内出现函数调用缺陷一、缺陷二、坑二
运行时统计统一锁封装内的 lock_stat_t争抢率、最大等待、最大持有
持有者记录调试版记录 owner + 时间 + 文件行号超时定位、反转排查
锁顺序检查记录"当前任务持有栈",发现逆序获取时告警死锁预防
长持有告警hold_max 超阈值时打印调用栈大锁、临界区过长

其中"锁顺序检查"的收益特别高:它能在死锁发生之前就发现"有人在用相反的顺序加锁"。实现不复杂——每个任务维护一个已持有锁的栈,加锁时检查新锁是否在栈中且顺序更靠前。


Logo

社区规范:仅讨论OpenHarmony相关问题。

更多推荐