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

客户端 (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);
    }
    
    // 以只写方式打开 FIFO（会阻塞直到有读者）
    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

运行顺序需注意：先启动服务端（阻塞等待连接），再启动客户端。

共享内存

共享内存是进程间通信中速度最快的方式，因为它避免了内核与用户空间之间的数据拷贝。

原理与地址空间

共享内存的核心在于让不同的进程映射到同一块物理内存区域。操作系统通过页表将虚拟地址映射到物理地址，使得多个进程的虚拟地址空间可以指向同一物理页。

在进程地址空间布局中，共享内存通常位于堆和栈之间的共享区。动态库也是利用这一机制实现代码共享的。

关键系统调用

1. shmget: 创建或获取共享内存标识符。
   • 需要指定键值（key）、大小和权限。
   • 键值通常由 ftok 生成，确保唯一性。
2. shmat: 将共享内存挂接到当前进程的虚拟地址空间。
   • 返回一个指针，后续可直接通过指针访问数据。
   • 无需系统调用即可读写，这是其高效的原因。
3. shmdt: 解除共享内存的映射（去关联）。
4. shmctl: 控制共享内存，包括删除（IPC_RMID）和查询属性（IPC_STAT）。

注意事项

• 键值冲突：IPC_CREAT | IPC_EXCL 标志用于确保新创建，避免覆盖已有的共享内存。
• 生命周期：共享内存的生命周期属于内核，而非进程。即使所有进程退出，若未显式删除，重启前仍可能残留。
• 对齐问题：建议大小设置为 4096 的整数倍，否则底层可能会向上对齐导致浪费。
• 同步保护：共享内存本身不提供互斥保护。多进程同时读写可能导致数据竞争，需配合信号量使用。

封装类示例

为了简化操作，我们可以将共享内存的管理封装为 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;

static std::string ToHex(int data) {
    char hex[64];
    snprintf(hex, sizeof(hex), "0x%x", data);
    return hex;
}

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

private:
    key_t GetKey() {
        _key = ftok(proj_name.c_str(), proj_id);
        if (_key < 0) perror("ftok");
        return _key;
    }

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

public:
    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 GetShmAttr() {
        struct shmid_ds ds;
        int n = shmctl(_shmid, IPC_STAT, &ds);
        if (n < 0) { perror("shmctl"); return; }
        std::cout << "pid: " << getpid() << std::endl;
        std::cout << "creator_pid: " << ds.shm_cpid << std::endl;
        std::cout << "size: " << ds.shm_segsz << std::endl;
        std::cout << "key: " << ToHex(ds.shm_perm.__key) << std::endl;
    }

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

    bool Detach() {
        return shmdt(_start) == 0;
    }

    void Debug() {
        std::cout << "key: " << ToHex(_key) << std::endl;
        std::cout << "shmid: " << _shmid << std::endl;
    }

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

#endif

Reader.cc (接收方)

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

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

int main() {
    Shm shm;
    shm.Create();
    sleep(3); // 模拟延迟，给 Writer 时间连接
    
    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;
}

Writer.cc (发送方)

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

Shm shm;

class Init {
public:
    Init() {
        shm.Get();
        addr = (char*)shm.Attach();
        std::cout << "addr: " << ToHex((long long)addr) << std::endl;
    }
    ~Init() {
        shm.Detach();
    }
    char* Addr() { return addr; }
public:
    char* addr;
};

Init init;

int main() {
    std::cout << "test Begin..." << std::endl;
    buffer_t* shm_data = (buffer_t*)init.Addr();
    shm_data->count = 0;
    memset(shm_data->buffer, 0, 4096);
    
    char ch = 'A';
    for (int i = 0; i < 26 * 2; i += 2, ch++) {
        shm_data->buffer[i] = ch;
        shm_data->buffer[i + 1] = ch;
        usleep(7000000);
        shm_data->count++;
        sleep(1);
    }
    return 0;
}

性能与总结

共享内存之所以最快，是因为它减少了数据拷贝次数。传统 IPC 可能需要两次拷贝（用户态 -> 内核态 -> 用户态），而共享内存只需一次（用户态 -> 用户态）。

但这也带来了风险：没有自带保护机制。任何挂接到该区域的进程都可以随时读写，可能导致数据覆盖。在实际生产中，必须结合信号量等同步原语来保证线程安全。

此外，清理工作不可忽视。使用 ipcs -m 查看，ipcrm -m 删除，或者在程序析构时自动调用 shmctl(..., IPC_RMID) 都是必要的维护手段。