C / C++ / 系统课时

使用读写锁与一次性初始化

使用读写锁与一次性初始化

当共享数据以读取为主、写入较少时,普通互斥量会把所有访问都串行化。本课用 pthread_rwlock_t 放宽只读并发,并用 pthread_once 保证进程内初始化动作只执行一次,最后给出二者的适用边界。

学习目标

  • 使用读锁、写锁和解锁操作保护共享状态,并正确处理返回码。
  • 使用 pthread_once 完成线程安全的一次性初始化。
  • 判断读写锁相对普通互斥量何时有收益、何时反而增加复杂度。

读写锁解决什么问题

pthread_rwlock_t 允许多个线程同时持有读锁,但写锁要求独占。它适合“读操作频繁、写操作较少,而且临界区不是极短”的共享数据,例如只读配置快照、路由表或内存索引。

读线程调用 pthread_rwlock_rdlock,写线程调用 pthread_rwlock_wrlock,完成访问后都用 pthread_rwlock_unlock。如果写比例很高,或者临界区只有几个简单指令,读写锁的管理成本可能高于 pthread_mutex_t,此时互斥量通常更直接。

用 pthread_once 建立共享状态

pthread_once_t 必须以 PTHREAD_ONCE_INIT 初始化。多个线程都可以调用 pthread_once,但指定的初始化函数只会完成一次;其他线程会等待这次初始化结束后再继续。

它特别适合创建进程级共享对象,例如初始化锁、构造查找表或加载只读配置。由于初始化函数的类型是 void (*)(void),它不能直接返回失败状态;如果初始化可能失败,应把结果记录到共享状态中,让每个调用者在 pthread_once 返回后检查。

下面的完整程序先由写线程把共享计数加一,再启动两个读线程并发读取。每个线程都调用 pthread_once,但读写锁只初始化一次。

c
#define _POSIX_C_SOURCE 200809L
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    pthread_rwlock_t lock;
    int value;
    int init_error;
} shared_state_t;

static shared_state_t state;
static pthread_once_t once_control = PTHREAD_ONCE_INIT;

static void init_state(void) {
    int rc = pthread_rwlock_init(&state.lock, NULL);
    if (rc != 0) {
        state.init_error = rc;
        return;
    }
    state.value = 0;
}

static void check_pthread(int rc, const char *what) {
    if (rc != 0) {
        fprintf(stderr, "%s: %s\n", what, strerror(rc));
        exit(EXIT_FAILURE);
    }
}

static void ensure_state(void) {
    check_pthread(pthread_once(&once_control, init_state), "pthread_once");
    if (state.init_error != 0) {
        check_pthread(state.init_error, "pthread_rwlock_init");
    }
}

static void *writer(void *arg) {
    (void)arg;
    ensure_state();

    check_pthread(pthread_rwlock_wrlock(&state.lock), "wrlock");
    state.value += 1;
    printf("writer: value=%d\n", state.value);
    check_pthread(pthread_rwlock_unlock(&state.lock), "unlock");
    return NULL;
}

static void *reader(void *arg) {
    long id = *(long *)arg;
    ensure_state();

    check_pthread(pthread_rwlock_rdlock(&state.lock), "rdlock");
    int snapshot = state.value;
    check_pthread(pthread_rwlock_unlock(&state.lock), "unlock");

    printf("reader %ld: value=%d\n", id, snapshot);
    return NULL;
}

int main(void) {
    pthread_t w;
    pthread_t readers[2];
    long ids[2] = {1, 2};

    check_pthread(pthread_create(&w, NULL, writer, NULL), "pthread_create");
    check_pthread(pthread_join(w, NULL), "pthread_join");

    for (int i = 0; i < 2; ++i) {
        check_pthread(
            pthread_create(&readers[i], NULL, reader, &ids[i]),
            "pthread_create"
        );
    }
    for (int i = 0; i < 2; ++i) {
        check_pthread(pthread_join(readers[i], NULL), "pthread_join");
    }

    check_pthread(pthread_rwlock_destroy(&state.lock), "pthread_rwlock_destroy");
    return 0;
}

编译并运行:

bash
cc -std=c11 -Wall -Wextra -pthread rwlock_once.c -o rwlock_once
./rwlock_once

预期输出如下;两个读线程的先后顺序可能不同。

text
writer: value=1
reader 1: value=1
reader 2: value=1

正确释放与错误处理

POSIX 线程函数通常直接返回错误码,因此应检查函数返回值,而不是在失败后读取 errno。示例中的 check_pthread 使用 strerror(rc) 把返回码转换为可读信息。

销毁读写锁前必须保证没有线程仍持有或等待该锁,所以资源释放通常放在所有相关线程 pthread_join 完成之后。一次性初始化对象本身没有对应的“撤销 once”操作;如果共享资源需要释放,应在进程退出路径中单独安排清理。

什么时候选择哪一种锁

读写锁的价值来自真实的并发读,而不是 API 名称本身。读多写少、读临界区较长时,它可能提升吞吐;写操作频繁、锁竞争很低或临界区很短时,普通互斥量往往更简单,也更容易推理。

选择时先保证正确性,再用负载测试验证收益。不要假设把 pthread_mutex_t 机械替换成 pthread_rwlock_t 就会更快;锁的公平性、调度和缓存争用都会影响最终结果。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

使用读写锁与一次性初始化

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通