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

5.3 代码示例

服务器端 (server.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() {
    // 创建 FIFO（如果已存在则忽略错误）
    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);
    }
    if (n == -1) perror("read");
    close(fd);
    unlink(FIFO_NAME); // 可选：删除 FIFO
    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);
    }
    
    // 以只写方式打开 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

运行顺序：先启动服务端，再启动客户端。

6. 共享内存

6.1 原理

共享内存允许不同的进程映射同一块物理内存区域。通过虚拟地址对物理内存进行读写，页表将虚拟地址映射到同一物理页。

优势：

• 无需内核拷贝，速度最快。
• 用户空间直接访问，无需频繁系统调用。

6.2 准备工作

6.2.1 Header Only 模式

为了减少文件数量，简化开发，可以使用 .hpp 头源混合模式，将声明和定义放在同一个文件中。

6.2.2 shmget 与 Key 值

创建共享内存返回标识符（shmid）。为了唯一标识，需要使用键值（key）。

• ftok：通过文件路径和项目 ID 生成 key，保证唯一性。
• shmget：创建或获取共享内存段。

6.3 代码书写与封装

我们将共享内存操作封装为类，方便复用。

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() {}

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 << ds.shm_cpid << std::endl;
        std::cout << ds.shm_segsz << std::endl;
        std::cout << ToHex(ds.shm_perm.__key) << std::endl;
    }
    void* Attach() { return shmat(_shmid, nullptr, 0); }
    void Detach() { shmdt(_start); }
    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;
};

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

Reader.cc (获取方)

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

int main() {
    Shm shm;
    shm.Get();
    shm.Debug();
    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 <string.h>

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_ptr = (buffer_t*)init.Addr();
    shm_ptr->count = 0;
    memset(shm_ptr->buffer, 0, 4096);
    char ch = 'A';
    for (int i = 0; i < 26 * 2; i += 2, ch++) {
        shm_ptr->buffer[i] = ch;
        shm_ptr->buffer[i + 1] = ch;
        shm_ptr->count++;
        sleep(1);
    }
    return 0;
}

6.4 注意事项

1. 去关联：删除共享内存前一般要先去关联 (shmdt)。
2. 大小对齐：建议设置为 4096 的整数倍，避免浪费或越界风险。
3. 保护机制：共享内存本身没有自带保护，需配合信号量实现互斥。
4. 性能：由于直接映射用户空间，无需内核拷贝，是 IPC 中速度最快的方式。

7. 结尾

本文涵盖了 Linux 下主要的进程间通信方式，从管道到共享内存，重点讲解了底层原理与代码实现。掌握这些技术对于编写高性能、高可靠性的系统程序至关重要。