Linux 进程间通信进阶：管道与共享内存实战

通过 fork 创建固定数量的子进程，利用管道进行任务分发。注意处理 waitpid 和信号掩码，防止意外中断。

5. 命名管道

匿名管道受限于父子进程关系，而命名管道（FIFO）允许毫不相干的进程通信。

关键细节

• 客户端不需要建立管道：只需打开已存在的 FIFO 文件。
• 阻塞行为：首次打开读端时，如果没有写端，open 会阻塞；反之亦然。这天然形成了一种同步机制。
• 无需 C 语言 \0：读写的是原始字节流，不像字符串函数那样依赖结尾符。
• 权限设置：使用 mkfifo 创建时需指定权限（如 0666）。

服务端与客户端代码结构

server.cc (服务端)

服务端先启动，打开 FIFO 进行读写。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

#define FIFO_NAME "fifo"

int main() {
    if (mkfifo(FIFO_NAME, 0666) == -1) {
        perror("mkfifo");
    }
    printf("Server waiting for client...\n");
    
    int fd = open(FIFO_NAME, O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(1);
    }
    printf("Client connected.\n");
    
    char buf[1024];
    ssize_t n;
    while ((n = read(fd, buf, sizeof(buf) - 1)) > 0) {
        buf[n] = '\0';
        printf("client say# %s", buf);
        fflush(stdout);
    }
    close(fd);
    unlink(FIFO_NAME);
    return 0;
}

client.cc (客户端)

客户端随后启动，写入数据。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

#define FIFO_NAME "fifo"

int main() {
    printf("Please Enter@ ");
    fflush(stdout);
    
    char msg[1024];
    if (fgets(msg, sizeof(msg), stdin) == NULL) {
        perror("fgets");
        exit(1);
    }
    
    int fd = open(FIFO_NAME, O_WRONLY);
    if (fd == -1) {
        perror("open");
        exit(1);
    }
    write(fd, msg, strlen(msg));
    close(fd);
    return 0;
}

Makefile

all: client server
client: client.cc
	g++ -o $@ $^ -std=c++11
server: server.cc
	g++ -o $@ $^ -std=c++11
.PHONY: clean
clean:
	rm -f client server

运行顺序

必须先启动服务器（打开读端），再启动客户端（打开写端），否则客户端的 open 会一直阻塞。

6. 共享内存

共享内存是速度最快的 IPC 方式，因为它避免了数据拷贝，直接映射到进程地址空间。

原理

通过页表映射，让不同进程看到同一块物理内存。动态库就是典型的共享区应用。

• 用户空间访问：创建和删除需要系统调用，但读写共享内存时，用户可以直接通过指针访问，无需再次陷入内核。
• 地址布局：共享内存位于堆栈之间，具体位置取决于虚拟地址空间的分配策略。

核心系统调用

1. shmget: 创建或获取共享内存标识符。需要 Key 值来唯一标识。
2. shmat: 将共享内存挂接到当前进程的虚拟地址空间。
3. shmdt: 解除挂接（去关联）。
4. shmctl: 控制共享内存，如删除 (IPC_RMID)。

Key 值的选择

Key 值用于在内核中唯一标识共享内存段。可以使用 ftok 函数结合文件路径和项目 ID 生成，避免硬编码冲突。

key_t GetKey() {
    key_t k = ftok("/home", 0x6666);
    if (k < 0) {
        perror("ftok");
    }
    return k;
}

代码演示：封装类 Shm.hpp

为了简化使用，我们可以封装一个类来处理创建、挂接和删除。

#ifndef __SHM_HPP
#define __SHM_HPP
#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <sys/shm.h>
#include <string>

const std::string proj_name = "/home";
const int proj_id = 0x6666;
const int g_size = 4096;

class Shm {
public:
    Shm(int size = g_size) : _shmid(-1), _size(size), _key(0) {}
    ~Shm() { Detach(); Delete(); }

    bool Create() {
        return CreateCoreHelper(IPC_CREAT | IPC_EXCL | 0666);
    }

    bool Get() {
        return CreateCoreHelper(IPC_CREAT);
    }

    bool Delete() {
        int n = shmctl(_shmid, IPC_RMID, NULL);
        return n < 0 ? false : true;
    }

    void* Attach() {
        return shmat(_shmid, nullptr, 0);
    }

    void Detach() {
        shmdt(_start);
    }

private:
    key_t GetKey() {
        _key = ftok(proj_name.c_str(), proj_id);
        return _key;
    }

    bool CreateCoreHelper(int flags) {
        key_t k = GetKey();
        _shmid = shmget(k, _size, flags);
        if (_shmid < 0) {
            perror("shmget");
            return false;
        }
        return true;
    }

    key_t _key;
    int _shmid;
    int _size;
    void* _start;
};
#endif

Reader.cc 与 Writer.cc

一方负责创建，另一方负责获取。不能双方都创建，否则无法建立通信信道。

// Reader.cc
#include "Shm.hpp"
#include <iostream>

int main() {
    Shm shm;
    shm.Create();
    sleep(3);
    shm.Attach();
    // 此处可添加读写逻辑
    shm.Detach();
    shm.Delete();
    return 0;
}

// Writer.cc
#include "Shm.hpp"
#include <iostream>

int main() {
    Shm shm;
    shm.Get(); // 仅获取，不创建
    shm.Attach();
    // 写入数据
    shm.Detach();
    return 0;
}

注意事项

1. 大小对齐：建议设置为 4096 的整数倍，否则底层会向上对齐申请，造成浪费。
2. 保护机制：共享内存本身没有锁，多进程同时读写需配合信号量使用。
3. 清理残留：程序异常退出可能导致共享内存残留，可使用 ipcs -m 查看，ipcrm -m 删除。

7. 总结

• 管道：适合父子进程，简单但功能有限。
• 命名管道：适合任意进程，有文件系统入口。
• 共享内存：速度最快，但需自行处理同步问题。

在实际开发中，根据性能需求和进程关系选择合适的 IPC 方式，并注意资源的生命周期管理。