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

5.2 代码示例

服务端（写端）

#include <iostream>
#include <cstdio>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    const char* fifo = "myfifo";
    int wfd = open(fifo, O_WRONLY);
    if (wfd < 0) {
        perror("open");
        return 1;
    }

    std::string msg;
    while (std::cin >> msg) {
        write(wfd, msg.c_str(), msg.size());
    }
    close(wfd);
    return 0;
}

客户端（读端）

#include <iostream>
#include <cstdio>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>

int main() {
    const char* fifo = "myfifo";
    umask(0);
    if (mkfifo(fifo, 0666) == -1 && errno != EEXIST) {
        perror("mkfifo");
        return 1;
    }

    int rfd = open(fifo, O_RDONLY);
    if (rfd < 0) {
        perror("open");
        return 2;
    }

    char buf[1024];
    ssize_t n;
    while ((n = read(rfd, buf, sizeof(buf) - 1)) > 0) {
        buf[n] = '\0';
        std::cout << "Received: " << buf << std::endl;
    }
    close(rfd);
    unlink(fifo); // 清理 FIFO 文件
    return 0;
}

6. 共享内存（Shared Memory）

共享内存是 System V IPC 中速度最快的通信方式。

6.1 工作原理

1. 物理内存分配：OS 在物理内存中开辟一块区域。
2. 页表映射：将该物理区域映射到不同进程的虚拟地址空间（通常位于堆栈之间的共享区）。
3. 直接访问：映射完成后，进程可直接通过指针读写该内存，无需系统调用（创建/删除除外）。

6.2 核心系统调用

6.3 关键特性与注意事项

• 生命周期随内核：进程退出不会自动释放共享内存，必须显式调用 shmctl 删除或使用 ipcrm -m shmid 命令清理。
• Key 值生成：推荐使用 ftok(path, proj_id) 算法，结合文件 inode 和项目 ID 生成唯一 key_t。
• 无内置同步机制：共享内存本身不提供互斥或同步保护。多进程并发读写时，必须配合信号量或互斥锁使用，否则会导致数据覆盖或脏读。
• 大小对齐：建议设置为系统页大小（通常 4096 字节）的整数倍。OS 会向上对齐，非整数倍会浪费空间且可能掩盖越界访问。

6.4 C++ 封装示例

#ifndef SHM_HPP
#define SHM_HPP

#include <iostream>
#include <string>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <unistd.h>

class Shm {
public:
    Shm(int size = 4096) : _shmid(-1), _size(size), _key(0), _addr(nullptr) {}
    ~Shm() { if (_addr) Detach(); }

    bool Create() {
        _key = ftok("/tmp", 0x66);
        if (_key < 0) { perror("ftok"); return false; }
        _shmid = shmget(_key, _size, IPC_CREAT | IPC_EXCL | 0666);
        return _shmid >= 0;
    }

    bool Get() {
        _key = ftok("/tmp", 0x66);
        if (_key < 0) { perror("ftok"); return false; }
        _shmid = shmget(_key, _size, IPC_CREAT);
        return _shmid >= 0;
    }

    void* Attach() {
        _addr = shmat(_shmid, nullptr, 0);
        return (_addr == (void*)-1) ? nullptr : _addr;
    }

    void Detach() {
        if (_addr) shmdt(_addr);
        _addr = nullptr;
    }

    bool Delete() {
        return shmctl(_shmid, IPC_RMID, nullptr) == 0;
    }

    void PrintInfo() {
        struct shmid_ds ds;
        shmctl(_shmid, IPC_STAT, &ds);
        std::cout << "Key: " << std::hex << ds.shm_perm.__key << std::dec
                  << ", Size: " << ds.shm_segsz << " bytes" << std::endl;
    }

private:
    key_t _key;
    int _shmid;
    int _size;
    void* _addr;
};
#endif

6.5 总结

1. 零拷贝/少拷贝：数据直接写入对方可见的内存，无需经过内核缓冲区二次拷贝。
2. 速度最快：是进程间大数据量传输的首选方案。
3. 需外部同步：必须结合信号量等机制保证读写安全。