操作系统 / 系统课时

用共享内存和信号组装数据通道

用共享内存和信号组装数据通道

当多个本机进程需要频繁交换数据时,可以把大块数据放进共享内存,把信号只当作“有新数据”的通知。本篇用环形缓冲区、进程共享互斥量和 SIGUSR1 组装一个可运行的数据通道,并验证普通信号发生合并时真实消息仍保存在共享内存中。

学习目标

  • 理解“共享内存传数据、信号做通知”的职责分离。
  • 用 shm_open、mmap、进程共享互斥量和 sigwait 完成生产消费链路。
  • 能识别缓冲区满、普通信号合并和进程异常退出带来的边界问题。

把数据面和通知面分开

共享内存适合承载数据,因为生产者写入后消费者无需经过内核复制整段消息;信号适合做轻量通知,但信号本身不应承担业务数据。下面的实现把消息保存在共享环形缓冲区,只用 SIGUSR1 提醒消费者“缓冲区可能有数据”。

共享内存数据面与信号通知面的协作关系

生产者只在缓冲区从空变为非空时发送 SIGUSR1,消费者被唤醒后一次把当前缓冲区排空。这样不会为每条消息都支付一次信号通知成本;即使普通信号发生合并,真实消息仍保存在共享内存中。

实现共享环形缓冲区

下面程序使用一个共享内存对象。生产者负责创建并初始化它,消费者打开同一对象后登记自己的 PID。pthread_mutexattr_setpshared 让互斥量可以跨进程保护 head、tail 和消息槽。

c
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>

#define SHM_NAME "/anystack_ipc_channel"
#define CAPACITY 16
#define MSG_SIZE 256

typedef struct {
    unsigned long seq;
    char data[MSG_SIZE];
} message_t;

typedef struct {
    pthread_mutex_t lock;
    size_t head;
    size_t tail;
    pid_t consumer_pid;
    unsigned long next_seq;
    message_t slots[CAPACITY];
} channel_t;

static void die(const char *msg) {
    perror(msg);
    exit(EXIT_FAILURE);
}

static channel_t *map_channel(int create) {
    int flags = create ? (O_CREAT | O_EXCL | O_RDWR) : O_RDWR;
    int fd = shm_open(SHM_NAME, flags, 0600);
    if (fd == -1) die("shm_open");

    if (create && ftruncate(fd, sizeof(channel_t)) == -1) die("ftruncate");

    channel_t *ch = mmap(NULL, sizeof(*ch), PROT_READ | PROT_WRITE,
                         MAP_SHARED, fd, 0);
    close(fd);
    if (ch == MAP_FAILED) die("mmap");
    return ch;
}

static void run_producer(void) {
    shm_unlink(SHM_NAME);
    channel_t *ch = map_channel(1);
    memset(ch, 0, sizeof(*ch));

    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
    pthread_mutex_init(&ch->lock, &attr);
    pthread_mutexattr_destroy(&attr);

    puts("producer ready; start consumer");
    fflush(stdout);
    for (;;) {
        pthread_mutex_lock(&ch->lock);
        pid_t pid = ch->consumer_pid;
        pthread_mutex_unlock(&ch->lock);
        if (pid != 0) break;
        struct timespec delay = {.tv_sec = 0, .tv_nsec = 10000000L};
        nanosleep(&delay, NULL);
    }

    char line[MSG_SIZE];
    while (fgets(line, sizeof(line), stdin)) {
        line[strcspn(line, "\n")] = '\0';

        for (;;) {
            pthread_mutex_lock(&ch->lock);
            size_t next = (ch->head + 1) % CAPACITY;
            if (next != ch->tail) {
                int need_notify = (ch->head == ch->tail);
                message_t *slot = &ch->slots[ch->head];
                slot->seq = ++ch->next_seq;
                snprintf(slot->data, MSG_SIZE, "%s", line);
                ch->head = next;
                pid_t pid = ch->consumer_pid;
                pthread_mutex_unlock(&ch->lock);
                if (need_notify && kill(pid, SIGUSR1) == -1) die("kill");
                break;
            }
            pthread_mutex_unlock(&ch->lock);
            struct timespec delay = {.tv_sec = 0, .tv_nsec = 10000000L};
            nanosleep(&delay, NULL);
        }

        if (strcmp(line, "quit") == 0) break;
    }

    munmap(ch, sizeof(*ch));
    shm_unlink(SHM_NAME);
}

static void run_consumer(void) {
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);
    int rc = pthread_sigmask(SIG_BLOCK, &set, NULL);
    if (rc != 0) {
        errno = rc;
        die("pthread_sigmask");
    }

    channel_t *ch = map_channel(0);
    pthread_mutex_lock(&ch->lock);
    ch->consumer_pid = getpid();
    pthread_mutex_unlock(&ch->lock);
    printf("consumer ready pid=%ld\n", (long)getpid());

    for (;;) {
        int sig;
        rc = sigwait(&set, &sig);
        if (rc != 0) {
            errno = rc;
            die("sigwait");
        }

        for (;;) {
            message_t item;

            pthread_mutex_lock(&ch->lock);
            if (ch->tail == ch->head) {
                pthread_mutex_unlock(&ch->lock);
                break;
            }
            item = ch->slots[ch->tail];
            ch->tail = (ch->tail + 1) % CAPACITY;
            pthread_mutex_unlock(&ch->lock);

            printf("received seq=%lu data=%s\n", item.seq, item.data);
            if (strcmp(item.data, "quit") == 0) {
                munmap(ch, sizeof(*ch));
                return;
            }
        }
    }
}

int main(int argc, char **argv) {
    if (argc != 2 || (strcmp(argv[1], "producer") != 0 &&
                      strcmp(argv[1], "consumer") != 0)) {
        fprintf(stderr, "usage: %s producer|consumer\n", argv[0]);
        return EXIT_FAILURE;
    }

    if (strcmp(argv[1], "producer") == 0) run_producer();
    else run_consumer();
    return EXIT_SUCCESS;
}

预期结果:编译后可用同一个二进制分别启动生产者和消费者;生产者写入共享缓冲区,消费者由 SIGUSR1 唤醒并批量读取,不通过信号传递消息正文。

编译并验证链路

先编译程序,在终端 A 启动生产者,再在终端 B 启动消费者。消费者登记 PID 后,回到终端 A 输入三行数据。

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

预期输出:

text
producer ready; start consumer

消费者终端执行:

bash
./channel consumer

预期输出:

text
consumer ready pid=<ID>

随后在生产者终端依次输入 alpha、beta、quit。消费者会输出与写入顺序一致的消息;前面的 <ID> 是运行期值,实际结果可能不同。

text
received seq=1 data=alpha
received seq=2 data=beta
received seq=3 data=quit

每个槽保存自己的序号,因此即使一次唤醒批量取出多条消息,也能检查是否发生跳号。

处理边界和故障

环形缓冲区满时,示例让生产者短暂等待,避免覆盖消费者尚未读取的数据。真实服务通常还要定义背压策略,例如阻塞、丢弃低优先级消息,或改用信号量、eventfd 等可计数通知机制。

另一个风险是进程在持有互斥量时崩溃。这里为了突出数据面与通知面的组合,没有加入 robust mutex 恢复逻辑;生产环境应使用可恢复锁策略,或选择带明确崩溃恢复语义的队列结构。示例启动时主动 shm_unlink 也只适合单实例实验,正式服务应先确认旧实例已经退出。共享内存负责数据持久于一次通知,信号只负责唤醒,这个职责边界是整条链路可靠性的关键。

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

目录与阅读设置

阅读设置

17

记录一个想法

用共享内存和信号组装数据通道

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

登录哪都通