操作系统 / 系统课时
用共享内存和信号组装数据通道
用共享内存和信号组装数据通道
当多个本机进程需要频繁交换数据时,可以把大块数据放进共享内存,把信号只当作“有新数据”的通知。本篇用环形缓冲区、进程共享互斥量和 SIGUSR1 组装一个可运行的数据通道,并验证普通信号发生合并时真实消息仍保存在共享内存中。
学习目标
- 理解“共享内存传数据、信号做通知”的职责分离。
- 用
shm_open、mmap、进程共享互斥量和sigwait完成生产消费链路。 - 能识别缓冲区满、普通信号合并和进程异常退出带来的边界问题。
把数据面和通知面分开
共享内存适合承载数据,因为生产者写入后消费者无需经过内核复制整段消息;信号适合做轻量通知,但信号本身不应承担业务数据。下面的实现把消息保存在共享环形缓冲区,只用 SIGUSR1 提醒消费者“缓冲区可能有数据”。

生产者只在缓冲区从空变为非空时发送 SIGUSR1,消费者被唤醒后一次把当前缓冲区排空。这样不会为每条消息都支付一次信号通知成本;即使普通信号发生合并,真实消息仍保存在共享内存中。
实现共享环形缓冲区
下面程序使用一个共享内存对象。生产者负责创建并初始化它,消费者打开同一对象后登记自己的 PID。pthread_mutexattr_setpshared 让互斥量可以跨进程保护 head、tail 和消息槽。
#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 输入三行数据。
gcc -std=c11 -O2 -Wall -Wextra -pthread channel.c -o channel
./channel producer预期输出:
producer ready; start consumer消费者终端执行:
./channel consumer预期输出:
consumer ready pid=<ID>随后在生产者终端依次输入 alpha、beta、quit。消费者会输出与写入顺序一致的消息;前面的 <ID> 是运行期值,实际结果可能不同。
received seq=1 data=alpha
received seq=2 data=beta
received seq=3 data=quit每个槽保存自己的序号,因此即使一次唤醒批量取出多条消息,也能检查是否发生跳号。
处理边界和故障
环形缓冲区满时,示例让生产者短暂等待,避免覆盖消费者尚未读取的数据。真实服务通常还要定义背压策略,例如阻塞、丢弃低优先级消息,或改用信号量、eventfd 等可计数通知机制。
另一个风险是进程在持有互斥量时崩溃。这里为了突出数据面与通知面的组合,没有加入 robust mutex 恢复逻辑;生产环境应使用可恢复锁策略,或选择带明确崩溃恢复语义的队列结构。示例启动时主动 shm_unlink 也只适合单实例实验,正式服务应先确认旧实例已经退出。共享内存负责数据持久于一次通知,信号只负责唤醒,这个职责边界是整条链路可靠性的关键。