操作系统 / 系统课时

跨进程互斥锁怎样配置

跨进程互斥锁怎样配置

跨进程互斥不是把普通 pthread_mutex_t 放进共享内存就结束了。关键是让互斥锁对象本身位于共享映射区,并把属性设置为 PTHREAD_PROCESS_SHARED,这样不同进程才能围绕同一把锁保护共享状态。

学习目标

  • 配置可跨进程使用的 pthread_mutex_t
  • 用共享内存承载互斥锁和受保护数据
  • 验证并发更新不会因竞态而丢失

互斥锁为什么必须放在共享内存

普通全局变量在 fork() 后会进入各进程独立的虚拟地址空间。即使两个进程都拥有一个同名 pthread_mutex_t,只要它们不是同一个共享对象,就无法互相阻塞。

跨进程互斥需要同时满足两个条件:锁对象位于 MAP_SHARED 映射区;初始化互斥锁时,通过 pthread_mutexattr_setpshared() 将属性设为 PTHREAD_PROCESS_SHARED。受保护的数据通常也放在同一块共享内存里。

两个进程通过共享内存中的同一把互斥锁保护计数器

配置进程共享属性

下面的程序创建一块 POSIX 共享内存,把互斥锁和计数器一起映射进去,再派生 4 个子进程并发自增。每个子进程执行 100000 次更新;如果互斥正确,最终值应稳定为 400000。

c
#define _POSIX_C_SOURCE 200809L

#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

#define SHM_NAME "/ipc_mutex_demo"
#define WORKERS 4
#define LOOPS 100000

typedef struct {
    pthread_mutex_t mutex;
    int64_t counter;
} SharedState;

static void die_pthread(int rc, const char *what) {
    if (rc != 0) {
        errno = rc;
        perror(what);
        exit(EXIT_FAILURE);
    }
}

int main(void) {
    /* 先创建共享存储,再初始化其中唯一的一把进程共享锁。 */
    int fd = shm_open(SHM_NAME, O_CREAT | O_EXCL | O_RDWR, 0600);
    if (fd == -1) {
        perror("shm_open");
        return EXIT_FAILURE;
    }

    if (ftruncate(fd, sizeof(SharedState)) == -1) {
        perror("ftruncate");
        return EXIT_FAILURE;
    }

    SharedState *state = mmap(NULL, sizeof(*state),
                              PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (state == MAP_FAILED) {
        perror("mmap");
        return EXIT_FAILURE;
    }
    close(fd);

    /* PROCESS_SHARED 是跨进程互斥的关键属性。 */
    pthread_mutexattr_t attr;
    die_pthread(pthread_mutexattr_init(&attr), "pthread_mutexattr_init");
    die_pthread(pthread_mutexattr_setpshared(
                    &attr, PTHREAD_PROCESS_SHARED),
                "pthread_mutexattr_setpshared");
    die_pthread(pthread_mutex_init(&state->mutex, &attr),
                "pthread_mutex_init");
    die_pthread(pthread_mutexattr_destroy(&attr),
                "pthread_mutexattr_destroy");

    state->counter = 0;

    /* 所有子进程继承同一共享映射,并竞争同一个 mutex。 */
    for (int i = 0; i < WORKERS; ++i) {
        pid_t pid = fork();
        if (pid == -1) {
            perror("fork");
            return EXIT_FAILURE;
        }
        if (pid == 0) {
            for (int n = 0; n < LOOPS; ++n) {
                die_pthread(pthread_mutex_lock(&state->mutex),
                            "pthread_mutex_lock");
                state->counter++;
                die_pthread(pthread_mutex_unlock(&state->mutex),
                            "pthread_mutex_unlock");
            }
            _exit(EXIT_SUCCESS);
        }
    }

    for (int i = 0; i < WORKERS; ++i) {
        if (wait(NULL) == -1) {
            perror("wait");
            return EXIT_FAILURE;
        }
    }

    printf("counter=%lld\n", (long long)state->counter);

    die_pthread(pthread_mutex_destroy(&state->mutex),
                "pthread_mutex_destroy");
    munmap(state, sizeof(*state));
    shm_unlink(SHM_NAME);
    return EXIT_SUCCESS;
}

编译并运行:

bash
gcc -std=c11 -Wall -Wextra -O2 -pthread mutex_process.c -o mutex_process
./mutex_process

预期输出:

text
counter=400000

初始化顺序和生命周期

互斥锁只能由一个进程完成初始化,然后再让其他进程访问。最简单的做法是在 fork() 之前创建共享内存并初始化锁;如果进程彼此独立启动,则还需要额外约定“谁负责初始化、其他进程何时可以使用”。

销毁顺序同样重要。只有确认其他进程已经不再使用锁时,才能调用 pthread_mutex_destroy(),随后再 munmap() 和 shm_unlink()。如果仍有进程持锁或等待锁就销毁对象,行为未定义。

常见失败怎么定位

如果最终计数偶尔小于期望值,先确认所有进程映射的是同一共享对象,并且读改写操作完整地位于加锁与解锁之间。仅把数据放进共享内存、却把互斥锁留在进程私有内存中,仍然会产生竞态。

如果 pthread_mutexattr_setpshared() 返回错误,应该检查平台是否支持进程共享同步原语。生产环境还要考虑持锁进程异常退出的情况;普通互斥锁不会自动恢复一致性,此时可进一步评估 robust mutex,但它解决的是“持锁者死亡后的恢复”,不是基本的跨进程共享配置。

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

目录与阅读设置

阅读设置

17

记录一个想法

跨进程互斥锁怎样配置

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

登录哪都通