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

命名管道

命名管道（FIFO）允许毫不相干的进程之间进行通信。它本质上是一个符号链接，指向内核中的缓冲区。

服务端与客户端实现

服务端先打开 FIFO 读端，客户端打开写端。注意，打开写端时会阻塞直到有读端打开，反之亦然。

server.cc

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

using namespace std;

int main() {
    cout << "open begin" << endl;
    int wfd = open("fifo", O_WRONLY);
    if (wfd < 0) {
        perror("open");
        return 1;
    }
    cout << "open end" << endl;

    string outstring;
    while (true) {
        cout << "Please Enter@ ";
        cin >> outstring;
        write(wfd, outstring.c_str(), outstring.size());
    }
    close(wfd);
    return 0;
}

client.cc

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

using namespace std;

int main() {
    umask(0);
    mkfifo("fifo", 0666);

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

    char inbuffer[1024];
    while (true) {
        ssize_t n = read(rfd, inbuffer, sizeof(inbuffer) - 1);
        if (n > 0) {
            inbuffer[n] = 0;
            cout << "client say# " << inbuffer << endl;
        } else if (n == 0) {
            break;
        } else {
            perror("read");
            break;
        }
    }
    close(rfd);
    unlink("fifo");
    return 0;
}

共享内存

共享内存是 IPC 中速度最快的方式，因为它不需要内核拷贝数据，直接映射到用户空间。

原理

不同进程通过页表映射到同一块物理内存。创建和删除需要系统调用，但读写可以直接通过指针访问，无需再次系统调用。

关键系统调用

• shmget：创建或获取共享内存标识符。
• shmat：挂接共享内存到进程地址空间。
• shmdt：去关联共享内存。
• shmctl：控制共享内存，包括删除。

键值（Key）设置

共享内存需要一个唯一的标识符。可以使用 ftok 函数将文件路径和项目 ID 转换为 key 值，确保唯一性。

key_t GetKey() {
    const string proj_name = "/home";
    const int proj_id = 0x6666;
    key_t k = ftok(proj_name.c_str(), proj_id);
    if (k < 0) {
        perror("ftok");
    }
    return k;
}

完整示例：Reader/Writer

使用 C++ 类封装共享内存操作，简化流程。

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() {
        key_t k = GetKey();
        _shmid = shmget(k, _size, IPC_CREAT | IPC_EXCL | 0666);
        return _shmid >= 0;
    }

    bool Get() {
        key_t k = GetKey();
        _shmid = shmget(k, _size, IPC_CREAT);
        return _shmid >= 0;
    }

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

    void Detach() {
        if (_start) shmdt(_start);
    }

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

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

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

Writer.cc

#include "Shm.hpp"
#include <iostream>
#include <cstring>

struct buffer_t {
    int count;
    char buffer[26 * 2];
};

int main() {
    Shm shm;
    shm.Get();
    void* addr = shm.Attach();
    buffer_t* shm_addr = (buffer_t*)addr;

    shm_addr->count = 0;
    memset(shm_addr->buffer, 0, 4096);

    char ch = 'A';
    for (int i = 0; i < 26 * 2; i += 2, ch++) {
        shm_addr->buffer[i] = ch;
        shm_addr->buffer[i + 1] = ch;
        shm_addr->count++;
        usleep(7000000);
    }
    return 0;
}

Reader.cc

#include "Shm.hpp"
#include <iostream>
#include <unistd.h>

struct buffer_t {
    int count;
    char buffer[26 * 2];
};

int main() {
    Shm shm;
    shm.Create();
    sleep(1);
    void* addr = shm.Attach();
    buffer_t* shm_addr = (buffer_t*)addr;

    int old = shm_addr->count;
    while (true) {
        if (old != shm_addr->count) {
            std::cout << "count : " << shm_addr->count << std::endl;
            std::cout << "data : " << shm_addr->buffer << std::endl;
            old = shm_addr->count;
        }
        usleep(50000);
        if (shm_addr->count >= 26) break;
    }
    shm.Detach();
    shm.Delete();
    return 0;
}

注意事项

1. 大小对齐：建议设置为 4096 的整数倍，避免浪费。
2. 保护机制：共享内存本身没有锁，需配合信号量防止竞态条件。
3. 清理：使用 ipcs -m 查看，ipcrm -m 删除残留共享内存。
4. 权限：确保读写权限设置正确，避免其他进程非法访问。