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

5. 命名管道

5.1 客户端无需建立管道

命名管道（FIFO）允许毫不相干的两个进程进行通信，客户端不需要像匿名管道那样先由父进程创建。

5.2 通信时机

在打开和关闭管道之间，客户端可以进行通信。注意，打开管道时可能会阻塞，直到另一端也打开。

5.3 字符串处理

使用 C++ std::string 或 write 函数时，不需要手动添加 C 语言的 \0 结束符，除非是字符串操作函数。

5.4 父进程无关性

命名管道连接的两个进程，其父进程可以完全不同，这打破了血缘限制。

5.4.1 服务端代码 (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");
        // 如果文件已存在，可以继续，但最好确认是 FIFO
    }
    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;
}

5.4.2 客户端代码 (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;
}

5.4.3 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

5.4.4 运行顺序

先启动服务端 (./server)，再启动客户端 (./client)。这样即可完成毫不相干进程之间的单向通信。

5.5 最终呈现的代码优化

使用 C++ 标准库可以更优雅地处理字符串和 IO。

服务器端 (server.cc)

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

int main() {
    std::cout << "open begin" << std::endl;
    int wfd = open("fifo", O_WRONLY);
    if (wfd < 0) {
        perror("open");
        return 1;
    }
    std::cout << "open end" << std::endl;
    
    std::string outstring;
    while (true) {
        std::cout << "Please Enter@ ";
        std::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>
#include "comm.h"

int main() {
    umask(0);
    int n = mkfifo(fifoname.c_str(), 0666);
    if (n < 0) {
        if (errno != EEXIST) {
            perror("mkfifo");
            return 1;
        }
    }
    
    std::cout << "open begin" << std::endl;
    int rfd = open(fifoname.c_str(), O_RDONLY);
    if (rfd < 0) {
        perror("open");
        return 2;
    }
    std::cout << "open end" << std::endl;
    
    char inbuffer[1024];
    while (true) {
        ssize_t n = read(rfd, inbuffer, sizeof(inbuffer)-1);
        if (n > 0) {
            inbuffer[n] = 0;
            std::cout << "client say# " << inbuffer << std::endl;
        } else if (n == 0) {
            break;
        } else {
            perror("read");
            break;
        }
    }
    close(rfd);
    unlink(fifoname.c_str());
    return 0;
}

5.6 命名管道的本质

命名管道本质上是一个符号链接，让不同进程找到同一个 inode。它不需要刷新到磁盘，只要有缓冲区即可。当进程打开管道时，读写端会自动同步。

5.7 应用场景

• 匿名管道：常用于竖线命令（如 ls | grep）。
• 命名管道：适用于互传文件的逻辑，或作为进程池的一种实现方式。

6. 共享内存

共享内存是 IPC 中速度最快的方式，因为它避免了内核拷贝。

6.1 原理

通过虚拟地址映射物理内存，让不同的进程看到同一份资源。动态库就是典型的共享区。

6.1.1 进程地址空间布局

文本、初始化数据、未初始化数据、堆、栈等区域中，共享内存、内存映射和共享库位于特定的共享区。堆和栈相对生长，而动态库被映射到共享区，只需加载一份物理内存，多个进程的页表映射到同一物理页。

6.1.2 关键问题

1. 谁做的？ 用户通过系统调用让操作系统完成。
2. 直接访问？ 是的，共享区属于用户空间，用户可以用指针直接访问，无需再次系统调用读写。
   • 总结：创建和删除 shm 需要系统调用，使用 shm 不需要（类似 malloc）。
3. 去关联：如果不使用共享内存了，需要先去掉页表的映射关系。

6.2 准备工作

6.2.1 .hpp 头源混合

使用 .hpp 文件可以将声明和定义放在一起，减少文件数量，方便阅读，但不利于打包成库。对于教程演示，这种方式更高效。

6.2.2 shmget 接口

创建成功后返回共享内存标识符（shmid）。为了唯一标识，需要设置 key 值。可以使用 ftok 函数结合路径和项目 ID 生成唯一的 key。

6.3 共享内存代码书写

采用面向对象封装，避免两边都创建导致冲突。

6.3.1 键值 (key)

Key 是共享内存的唯一标识符。建议使用 ftok 生成，而不是随机指定，以保证一致性。

6.3.2 权限与删除

• 查看：使用 ipcs -m 指令。
• 删除：使用 shmctl 系统调用或 ipcrm 指令。注意，默认情况下 key 值不能直接删除，需用 shmid。

6.3.3 挂接 (Attach)

使用 shmat 将共享内存挂接到当前进程的虚拟地址空间。失败返回 (void*)-1，成功返回起始地址。

6.4 代码演示（挂接）

Makefile

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

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 Debug() {
        std::cout << "key: " << ToHex(_key) << std::endl;
        std::cout << "shmid: " << _shmid << std::endl;
    }

private:
    key_t _key;
    int _shmid;
    int _size;
};
#endif

Reader.cc

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

int main() {
    Shm shm;
    shm.Create();
    sleep(3);
    shm.Attach();
    shm.Debug();
    shm.GetShmAttr();
    sleep(5);
    shm.Delete();
    return 0;
}

Writer.cc

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

int main() {
    Shm shm;
    shm.Get();
    shm.Debug();
    return 0;
}

6.5 共享内存收尾

在实际应用中，读写端需要配合结构体来管理数据。

Reader.cc (完整版)

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

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

int main() {
    Shm shm;
    shm.Create();
    sleep(100);
    char* addr = (char*)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_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;
}

6.6 补充说明

6.6.1 回顾

• 共享内存映射到虚拟地址空间，地址可能在堆栈之间。
• 生命周期随内核，不随进程。
• 删除前建议先解关联（Detach）。

6.6.2 性能与保护

• 结论 1：使用共享内存时，读写不需要系统调用，直接指针访问。
• 结论 2：共享内存是 IPC 中速度最快的，无之一。
• 结论 3：共享内存没有自带保护机制，任何挂接的进程都可随时访问，可能导致竞态条件。需配合信号量实现互斥。

6.6.3 大小设置

建议设置为 4096 的整数倍。若设置非对齐值，底层会向上对齐申请，造成空间浪费。

结尾

本文涵盖了 Linux 下进程间通信的核心机制，包括管道和共享内存的原理及实战代码。理解这些基础对于编写高性能并发程序至关重要。