PAYATHON 2026

atomic counter 检查 mutex 与 condition variable 关联的 memory ordering

技术老齐

结论

如果 cv_assoc 只用于统计关联的 condition variable 数量,这三个操作都可以使用 memory_order_relaxed:

atomic_load_explicit(&cxmtx->cv_assoc, memory_order_relaxed);
atomic_fetch_add_explicit(&cxmtx->cv_assoc, 1, memory_order_relaxed);
atomic_fetch_sub_explicit(&cxmtx->cv_assoc, 1, memory_order_relaxed);

memory_order_acquire 和 memory_order_release 用于在不同线程的内存访问之间建立顺序关系,不能保证线程读到所谓的“实时最新值”。这里只读取和修改计数,没有通过计数器发布或读取其他数据,所以不需要 acquire/release。

代码还存在对象生命周期问题。如果 mutex 已经销毁,某个 condition variable 却仍保留 cxmtx 指针,那么它稍后执行 finalizer 时就会访问已经释放的内存。atomic counter 可以帮助检测这种情况,却无法阻止 use-after-free。

为什么 memory_order_acquire 达不到预期效果

对于下面的代码:

if (atomic_load_explicit(&cxmtx->cv_assoc, memory_order_acquire) != 0) {
    CxingDebug(...);
}

是否调用 CxingDebug,只取决于这次 load 读到的数值。改用 memory_order_relaxed 也能正确完成这个判断。

当一个 acquire load 读到另一个线程通过 release 操作写入的值时,load 之后的普通内存访问可以观察到 release 之前的写入。Acquire 不会:

  • 等待并发的 fetch_add 或 fetch_sub 完成;
  • 保证读到某个“按实际时间计算的最新值”;
  • 影响 load 之前已经执行的 ValueDestroy;
  • 单独保证 mutex 能够安全销毁。

C 的并发执行中没有统一的“当前最新值”。atomic 对象有自己的 modification order,但只要其他线程仍在并发修改它,一次 load 就可能发生在这些修改之前或之后。memory order 无法消除这种并发关系。

memory_order_release 如何影响计数更新

无论使用哪种 memory order,atomic read-modify-write 操作对计数的修改本身都是原子的:

atomic_fetch_add_explicit(&m->cv_assoc, 1, memory_order_relaxed);
atomic_fetch_sub_explicit(&m->cv_assoc, 1, memory_order_relaxed);

memory_order_release 只约束该 atomic 操作之前的内存访问,防止它们移动到 release 操作之后。它不会充当“把 atomic 值刷新给其他线程”的开关。

原代码的执行顺序需要特别注意:

atomic_fetch_add_explicit(&ret->cxmtx->cv_assoc, 1,
                          memory_order_release);

pthread_cond_init(&ret->condvar, NULL);

这里的 release 无法把后续的 pthread_cond_init 发布给执行 acquire load 的线程,因为 release 只发布它前面的操作。

销毁路径也是如此:

atomic_fetch_sub_explicit(&cxcv->cxmtx->cv_assoc, 1,
                          memory_order_release);

pthread_cond_destroy(&cxcv->condvar);

计数先减到零,condition variable 随后才销毁。如果其他代码把计数为零理解为“所有 condition variable 已经完全销毁”,那么这个执行顺序不符合该含义。

计数只用于诊断时的写法

使用 relaxed 需要先通过其他生命周期机制保证以下条件:

  • mutex finalizer 执行时不会再创建新的关联;
  • 不会再有 condition variable finalizer 并发访问该 mutex;
  • cv_assoc 只用于断言或输出诊断信息。

代码可以写成:

typedef struct {
    arc_base_t arc;
    atomic_int cv_assoc;
    pthread_mutex_t mtx_proper;
    struct value_nativeobj vp;
} cxing_mutex_t;

void cxing_mutex_init(cxing_mutex_t *cxmtx)
{
    atomic_init(&cxmtx->cv_assoc, 0);
    pthread_mutex_init(&cxmtx->mtx_proper, NULL);
}

void cxing_mutex_fin(cxing_mutex_t *cxmtx)
{
    int count = atomic_load_explicit(
        &cxmtx->cv_assoc, memory_order_relaxed);

    if (count != 0) {
        CxingDebug("Mutex still has associated condition variables.\n");

        /*
         * 这里不能仅记录警告后继续释放 cxmtx,
         * 除非能够保证这些 condition variable 不再访问它。
         */
    }

    ValueDestroy(cxmtx->vp);
    pthread_mutex_destroy(&cxmtx->mtx_proper);
}

在 condition variable 成功初始化后再登记关联,计数的含义会更清楚:

int err = pthread_cond_init(&ret->condvar, NULL);
if (err != 0) {
    /* 释放 ret,并返回错误。 */
}

atomic_fetch_add_explicit(
    &ret->cxmtx->cv_assoc, 1, memory_order_relaxed);

如果计数的含义是“已经销毁的 condition variable 不再计入”,解除关联时可以先销毁,再递减:

void cxing_condvar_fin(cxing_condvar_t *cxcv)
{
    pthread_cond_destroy(&cxcv->condvar);

    atomic_fetch_sub_explicit(
        &cxcv->cxmtx->cv_assoc, 1, memory_order_relaxed);
}

整个过程中都必须保证 cxcv->cxmtx 有效。

mutex 的生命周期需要单独处理

现有代码让 condition variable 保存一个裸指针:

cxing_mutex_t *cxmtx;

如果 mutex 在 cv_assoc != 0 时继续销毁,剩余的 condition variable 稍后会执行:

atomic_fetch_sub_explicit(&cxcv->cxmtx->cv_assoc, 1, ...);

此时 cxcv->cxmtx 可能已经成为悬空指针,从而产生 undefined behavior。即使把 memory order 加强为 memory_order_seq_cst,这个问题依然存在。

通常可以让 condition variable 持有 mutex 的强引用。下面是伪代码,具体函数名需要替换为 runtime 的 ARC API:

/* 创建 condition variable 时 */
ret->cxmtx = args[0].proper.p;
cxing_mutex_retain(ret->cxmtx);

if (pthread_cond_init(&ret->condvar, NULL) != 0) {
    cxing_mutex_release(ret->cxmtx);
    /* 释放 ret,并返回错误。 */
}

atomic_fetch_add_explicit(
    &ret->cxmtx->cv_assoc, 1, memory_order_relaxed);
void cxing_condvar_fin(cxing_condvar_t *cxcv)
{
    pthread_cond_destroy(&cxcv->condvar);

    atomic_fetch_sub_explicit(
        &cxcv->cxmtx->cv_assoc, 1, memory_order_relaxed);

    cxing_mutex_release(cxcv->cxmtx);
}

只要 condition variable 还存在,这个引用就能阻止 mutex 进入 finalizer。此时 counter 仅用于诊断,引用关系负责保证安全。

如果不希望 condition variable 持有强引用,就需要设计明确的关闭协议,例如禁止新建关联,等待关联计数归零后再销毁 mutex。该协议还要处理“检查计数”与“新增关联”之间的竞态,单独执行一次 atomic load 无法解决这个问题。

何时需要 acquire/release

当 cv_assoc 同时承担同步或发布职责时,才需要考虑 acquire/release。例如,一个线程在递减计数前写入其他共享状态,而负责销毁的线程在观察到计数归零后还要读取这些状态,此时可以设计 release/acquire 同步。

这种设计需要明确规定:

  • 哪个 release 操作发布哪些数据;
  • 哪个 acquire 操作读取了对应的 release 或其 release sequence;
  • 如何保证 mutex 的内存在整个同步过程结束前始终有效;
  • 新关联如何与关闭操作互斥。

当前 counter 只统计数量,没有承担这些职责,因此使用 relaxed 即可。需要修正的是 mutex 与 condition variable 之间的所有权关系,同时处理初始化失败、并发关闭,以及执行 pthread_mutex_destroy 时仍有使用者等情况。

备注:内容仅供参考。