Linux 命名管道与共享内存基础 | 极客日志

C++

Linux 命名管道与共享内存基础

Linux 命名管道允许非血缘进程通过文件系统路径通信，数据存于内存缓冲区。共享内存提供最快进程间通信方式，需手动管理同步。本文介绍了 mkfifo 创建管道及 shmget/shmat/shmdt/shmctl 操作共享内存的原理与 C++ 实现代码，包含读写端逻辑及资源清理方法。

DevStack发布于 2026/2/70 浏览

Linux 命名管道与共享内存基础

背景

匿名管道的缺点在于只能用于有血缘关系的进程间通信。若要让两个毫不相干的进程进行通信，需要使用命名管道。

存储机制

要实现非血缘进程通信，首先需确保双方能访问同一个管道文件。命名管道通过文件系统路径实现唯一性，存储在文件系统中，拥有独立的文件路径和 inode，但数据不会写入磁盘，而是发生在内存级缓冲区中。

纯内存级缓冲区的通信方法包括：匿名管道、共享内存、消息队列。

建立命名管道

命令行创建

命名管道可以直接在命令行创建：

mkfifo "管道名"

创建后向管道写入数据，若没有读取端，写入操作会阻塞。查看文件大小通常为 0，说明数据未刷盘。读取结束后数据消失。删除管道使用 unlink 命令。

mkfifo 函数实现通信

函数原型：

int mkfifo(const char *filename, mode_t mode);

以下代码封装了命名管道的初始化和清理逻辑。

头文件封装类：

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

#define FIFO_FILE "./myfile"
#define MODE 0664
enum { FIFO_CREAT_FILE = 1, FIFO_DELETE_FILE, FIFO_OPEN_FILE };

class Init {
:
    () {
         n = (FIFO_FILE, MODE);
         (n == ) {
            ();
            (FIFO_CREAT_FILE);
        }
    }
    ~() {
         m = (FIFO_FILE);
         (m == ) {
            ();
            (FIFO_DELETE_FILE);
        }
    }
};

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown转HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。在线工具，Markdown转HTML在线工具，online
HTML转Markdown
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。在线工具，HTML转Markdown在线工具，online
JSON 压缩
通过删除不必要的空白来缩小和压缩JSON。在线工具，JSON 压缩在线工具，online
JSON美化和格式化
将JSON字符串修饰为友好的可读格式。在线工具，JSON美化和格式化在线工具，online

#include "commen.hpp"
using namespace std;

int main() {
    Init it;
    int fd = open(FIFO_FILE, O_RDONLY);
    cout << "server ready done" << endl;
    if (fd == -1) {
        perror("open");
        exit(FIFO_OPEN_FILE);
    }
    while (true) {
        char buffer[1024] = {0};
        int x = read(fd, buffer, sizeof(buffer));
        if (x > 0) {
            buffer[x] = 0;
            cout << "client say:" << buffer << endl;
        } else if (x == 0) {
            printf("client quit! me too! string errno %s, errno %d", strerror(errno), errno);
            break;
        } else {
            break;
        }
    }
    return 0;
}

#include "commen.hpp"
using namespace std;

int main() {
    int fd = open(FIFO_FILE, O_WRONLY);
    if (fd < 0) {
        perror("open");
        exit(FIFO_CREAT_FILE);
    }
    cout << "client ready done" << endl;
    string line;
    while (true) {
        cout << "please enter:" << endl;
        getline(cin, line);
        write(fd, line.c_str(), line.size());
    }
    close(fd);
    return 0;
}

int shmget(key_t key, size_t size, int shmflg);

key_t ftok(const char* pathname, int proj_id);

void *shmat(int shmid, const void *shmaddr, int shmflg);

int shmdt(const void *shmaddr);

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

#include <iostream>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>

using namespace std;

const int size = 4096;
const string pathname = "/home/jib";
const int proj_id = 0x6666;

key_t GetKey() {
    int k = ftok(pathname.c_str(), proj_id);
    if (k < 0) {
        perror("ftok");
        exit(1);
    }
    printf("ftok success! key is 0x%x\n", k);
    return k;
}

int GetShareMemHelper(int flag) {
    key_t k = GetKey();
    int shmid = shmget(k, size, flag);
    if (shmid < 0) {
        perror("shmget");
        exit(2);
    }
    printf("shmget success : %d", k);
    return shmid;
}

int Createshm() {
    return GetShareMemHelper(IPC_CREAT | 0666);
}

int Getshm() {
    return GetShareMemHelper(IPC_CREAT | 0666);
}

#define FIFO_FILE "./myfile"
#define MODE 0664
enum { FIFO_CREAT_FILE = 1, FIFO_DELETE_FILE, FIFO_OPEN_FILE };

class Init {
public:
    Init() {
        int n = mkfifo(FIFO_FILE, MODE);
        if (n == -1) {
            perror("mkfifo");
            exit(FIFO_CREAT_FILE);
        }
    }
    ~Init() {
        int m = unlink(FIFO_FILE);
        if (m == -1) {
            perror("unlink");
            exit(FIFO_DELETE_FILE);
        }
    }
};

#include "commen.hpp"
#include "log.hpp"
using namespace std;

int main() {
    Log log;
    Init init;
    int shmid = Createshm();
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    int fd = open(FIFO_FILE, O_CREAT | O_RDONLY);
    log.Info("server open success");
    if (fd < 0) {
        log.Fatal("error string : %s, error :%d", strerror(errno), errno);
        exit(FIFO_CREAT_FILE);
    }
    struct shmid_ds shmds;
    while (true) {
        char c;
        size_t s = read(fd, &c, 1);
        if (s < 0) break;
        else if (s == 0) break;
        cout << "Client Say:" << shmaddr << endl;
        shmctl(shmid, IPC_STAT, &shmds);
        cout << "shm size: " << shmds.shm_segsz << endl;
        cout << "shm nattch: " << shmds.shm_nattch << endl;
        printf("shm key: 0x%x\n", shmds.shm_perm.__key);
        cout << "shm mode: " << shmds.shm_perm.mode << endl;
    }
    shmdt(shmaddr);
    shmctl(shmid, IPC_RMID, nullptr);
    close(fd);
    return 0;
}

#include "commen.hpp"
#include "log.hpp"
using namespace std;

int main() {
    Log log;
    int shmid = Getshm();
    char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    int fd = open(FIFO_FILE, O_CREAT | O_WRONLY, MODE);
    if (fd < 0) {
        log.Fatal("error string :%s, errno :%d", strerror(errno), errno);
        exit(FIFO_OPEN_FILE);
    }
    while (true) {
        cout << "please enter :";
        fgets(shmaddr, 4096, stdin);
        write(fd, "c", 1);
    }
    shmdt(shmaddr);
    return 0;
}