Linux进程间通信（管道）

//Linux内核源码（部分）
struct files_struct {
  /*
   * read mostly part
   */
	atomic_t count;
	struct fdtable __rcu *fdt;
	struct fdtable fdtab;
  /*
   * written part on a separate cache line in SMP
   */
	spinlock_t file_lock ____cacheline_aligned_in_smp;
	int next_fd;
	unsigned long close_on_exec_init[1];
	unsigned long open_fds_init[1];
	struct file __rcu * fd_array[NR_OPEN_DEFAULT];	//文件指针数组
};

此时父进程可以打开匿名管道文件，fork 子进程后，子进程继承原有的文件系统关系，与父进程共享同一份文件资源，然后父子进程分别关闭读端与写端，实现匿名管道的单向关系，即可正常进行通信

具体流程：

父进程创建匿名管道，同时以读、写的方式打开匿名管道，此时会分配两个 fd
fork 创建子进程，子进程拥有自己的进程系统信息，同时会继承原父进程中的文件系统信息，此时子进程和父进程可以看到同一份资源：匿名管道 pipe
因为子进程继承了原有关系，因此此时父子进程对于 pipe 都有读写权限，需要确定数据流向，关闭不必要的 fd，比如父进程写、子进程读，或者父进程读、子进程写都可以

注意：

fork 创建子进程后，子进程会继承原父进程中的文件系统信息，这也就是父子进程都会同时向屏幕打印信息的原理，因为此时它们操作的是同一个文件！
父进程需要以读写的方式打开匿名管道 pipe，这样子进程在继承时，才不会发生权限丢失
创建出的匿名管道文件 pipe 虽然属于文件系统，但它是一个特殊文件，一个由 OS 提供的纯纯的内存文件，不需要将数据冲刷至磁盘中，只需要承担进程间通信任务即可
管道是一种半双工、单流向的通信方式，因为 pipe 只有一个缓冲区，所以这种方式才被叫做管道通信

2.2匿名管道

2.2.1接口pipe函数

#include <unistd.h>

int pipe(int pipefd[2]);

参数部分的pipefd是一个只有两个元素的整形数组，其中pipefd【0】为匿名管道的读端，pipefd【1】为匿名管道的写端

2.2.2代码演示

演示步骤：

创建匿名管道
创建子进程
关闭不需要的 fd
开始通信

#include <iostream>
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

int main()
{
    //创建匿名管道
    int pipefd[2];
    int ret = pipe(pipefd);
    assert(ret == 0);
    (void)ret;//防止release 报警

    //创建子进程
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        close(pipefd[1]);//关闭写端
        //code
        char buff[124];//缓冲区
        while(true)
        {
            int n = read(pipefd[0],buff,strlen(buff)-1);//预留位置存‘\0'
            buff[n] = '\0';     
           if (n >= 5 && n < 64)
            {
                // 读取到了信息
                cout << "子进程成功读取到信息：" << buff << endl;
            }
            else
            {
                // 未读取到信息
                if (n == 0)
                    cout << "子进程没有读取到信息，通信结束！" << endl;
                // 读取异常（消息过短）
                else
                    cout << "子进程读取数据量为：" << n << " 消息过短，通信结束！" << endl;
                break;
            }
        }
        close(pipefd[0]);//代码结束关闭读端
        exit(0);
    }
    //父进程
    close(pipefd[0]);
    //code
    //通信
    char buff[124];
    srand ((size_t)time(NULL));//种下一颗种子
    while(true)
    {
        int n = rand() % 26;
        for(int i = 0;i<n;i++)
        buff[i] = (rand() % 26) + 'A';
        buff[n] = '\n';

        cout<<"==========="<<endl;
        cout<< "我对你说："<<buff<<endl;
        write(pipefd[1],buff,strlen(buff));
        if (n < 5)
            break; // 消息过短时，不写入

        sleep(1);
    }

    close(pipefd[1]);
    int status = 0;
    waitpid(id,&status,0);
    if ((status & 0x7F))
    {
        printf("子进程异常退出，core dump: %d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
    }
    else
    {
        printf("子进程正常退出，退出码：%d\n", (status >> 8) & 0xFF);
    }
    return 0;
}

站在 文件描述符 的角度理解上述代码：

站在 内核（管道本质） 的角度理解上述代码：

所以，看待 管道 ，就如同看待 文件 一样！管道 的使用和 文件 一致，迎合 Linux一切皆文件思想

2.3管道读写规则

管道是一种半双工、单向流的通信方式，因此在成功创建匿名管道后，需要两个待通信的进程都能获得同一个 pipefd 数组

这就是匿名管道比较特殊的地方了：匿名管道只支持具有血缘关系的进程通信，如父子进程、兄弟进程等，因为只有继承了，才能共享到同一个 pipefd 数组

当通信双方都获得 pipefd 数组后，需要根据情况关闭不需要的 fd，确保单流向的原则

注：命名管道可以支持不具有血缘关系进程间通信

管道的读写规则：

PIPE_BUF 为管道大小，Linux 中为 4096 字节

当要写入的数据量不大于 PIPE_BUF 时，Linux 将保证写入的原子性
当要写入的数据量大于 PIPE_BUF 时，Linux 将不再保证写入的原子性
原子性：不存在中间状态，确保数据的安全性

2.4管道的特点

管道主要有以下几个特点：

1.单向通信，管道是半双工的一种特殊情况

管道就像单行道，只允许数据单向流通，即通知，如果想要实现两个进程间相互进行通信，需要创建两条管道，管道1：父进程写，子进程读；管道2：子进程写，父进程读

2.管道的本质是文件，因为 fd 的生命周期随进程而终止，所以管道的生命周期也是随着进程而结束的

当进程终止运行时，管道资源会被 OS 回收

3.匿名管道常用来进行具有 “血缘” 关系的进程，进行进程间通信（常用于父子进程间通信）

pipe 打开管道，并不清楚管道的名字等信息，这种管道称为匿名管道，因此匿名管道只能用于有血缘关系的进程 IPC，因为需要通过 fork 继承匿名管道信息

4.在管道中，写入与读取的次数并不是严格匹配的，此时读写次数没有强相关关系，管道是面向字节流读写的

面向字节流读写又称为流式服务：数据没有明确的分割，不分一定的报文段；与之相对应的是数据报服务：数据有明确的分割，拿数据按报文段拿

不论写端写入了多少数据，只要写端停止写入，读端都可以将数据读取
5.具有一定的协同能力，让读端和写端能够按照一定的步骤进行通信（自带同步机制）

当读端进行从管道中读取数据时，如果没有数据，则会阻塞，等待写端写入数据；如果读端正在读取，那么写端将会阻塞等待读端，因此管道自带同步与互斥机制

2.5应用场景

2.5.1场景一

父进程不写，此时管道为空，子进程尝试读取

伪代码段
// 父进程不写（空），子进程读

//子进程（尝试读取）
int cnt = 1;
while (true)
{
    char ch;
    read(pipefd[0], &ch, 1);
    cout << "已读取 " << cnt++ << " 字节的数据" << endl;
}

//父进程（不写）
while (true) {}

结果：因为管道为空，因此子进程无法读取，即读端阻塞

只有当写端写入数据后，读端才能正常读取

2.5.2场景二

父进程不断写入，直到管道写满，子进程不读取

伪代码段
//父进程写（满），子进程不读

//子进程（不读）
while (true) {}

//父进程（不断写入）
int cnt = 1; // 计数器
while (true)
{
    char ch = 'x';
    write(pipefd[1], &ch, 1); // 写入数据
    cout << "已写入 " << cnt++ << " 字节的数据" << endl;
}

结果：在一段时间后，管道被写满，写端无法写入数据，进入阻塞状态

只有当读端尝试将管道中的数据读走一部分后，写端才能继续写入

2.5.3场景三

通信的过程中，关闭写端，只保留读端

伪代码段
//写端写入一段信息后，就关闭

//子进程正常读取，并且对读取到的数据量进行判断
char buff[64];
while(true)
{
    int n = read(pipefd[0], buff, sizeof(buff) - 1);
    buff[n] = '\0';

    if(n == 0)
        cout << "写端已关闭，读取数据量为: " << n << " 字节" << endl;
    else
        cout << "成功读取到信息: " << buff << endl;

    sleep(1);
}

//父进程只写入一次数据，然后关闭写端
char buff[] = "Hello pipe!";
write(pipefd[1], buff, strlen(buff)); // 写入数据

close(pipefd[1]); // 关闭剩下的写端

结果：关闭写端后，读端会将匿名管道中的数据读取完后，再读，会读到 0，表示已读到文件末尾

如何理解？

因为管道是单流向通信，写端都关闭了，证明不会再有数据写入，因此当读端把剩余数据都读取后，每次都是读取 0 字节数据，表明此时已经读到了结尾，读端也可以结束读取了

2.5.4场景四

在通信过程中，关闭读端，只保留写端

注：这里将角色变换一下，方便父进程捕捉到子进程的退出信号

切换：父进程 -> 读端，子进程 -> 写端

伪代码段
//读端读取一段时间后，就关闭

//子进程不断写入
while (true)
{
    char buff[] = "Hello pipe!";
    write(pipefd[1], buff, strlen(buff)); // 写入数据
    sleep(1);
}

//父进程在读取五次信息后，就终止读取，关闭读端
char buff[64];
int cnt = 1;
while (true)
{
    int n = read(pipefd[0], buff, sizeof(buff) - 1);
    buff[n] = '\0';

    if (n == 0)
        cout << "写端已关闭，读取数据量为: " << n << " 字节" << endl;
    else
        cout << "成功读取到信息: " << buff << endl;

    // 读取五次后，关闭读端
    if (cnt++ == 5)
        break;
}

close(pipefd[0]);

// 父进程等待子进程结束
int status = 0;
waitpid(id, &status, 0);
printf("子进程异常退出，core dump: %d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));

结果：OS 不允许任何浪费资源的行为存在，如果关闭了读端，那么证明写端写了也没有，即没有存在的意义，于是 OS 会发出 13 号信号，终止写端进程

以上就是管道的四种特殊场景，不仅适用于匿名管道，同时也适用于命名管道

2.6匿名管道的大小

既然管道能被写满，那么管道的大小究竟是多少？

man 7 pipe

接着输入 /pipe capacity 即可搜索出管道的大小

3.进程池-进程控制

场景：父进程创建了一批子进程，并通过多条匿名管道与它们链接，父进程选择某个子进程，并通过匿名管道与子进程通信，并下达指定的任务让其执行

3.1逻辑设计

3.2具体功能实现

1、创建一批进程及管道
创建一批进程及管道

首先需要先创建一个包含进程信息的类，最主要的就是子进程的写端 fd，这样父进程才能通过此 fd 进行数据写入
循环创建管道、子进程，进行相应的管道链接操作，然后子进程进入任务等待状态，父进程将创建好的子进程信息注册
假设子进程获取了任务代号，那么应该根据任务代号，去执行相应的任务，否则阻塞等待
注意：因为是创建子进程，所以存在关系重复继承的情况，此时应该统计当前子进程的写端 fd，在创建下一个进程时，关闭无关的 fd

具体体现为：每次都把写端 fd 存储起来，在确定关系前 “清理” 干净

#define NAME_SIZE 64
// 封装一个包含各种必备信息的类

class ProcInfo
{
public:
    ProcInfo(pid_t id = pid_t(), int fd = int())
        : _childID(id), _wfd(fd), _num(++_count)
    {
        char buff[NAME_SIZE];
        snprintf(buff, sizeof buff, "Process %d [%d:%d]", _num, _childID, _wfd);
        _name = string(buff);
    }

    ~ProcInfo()
    {
        _childID = _wfd = 0;
    }

    pid_t _childID;  // pid
    int _wfd;        // 写端 fd
    string _name;    // 进程名
    int _num;   //编号
    static int _count; // 计数
};

int ProcInfo::_count = 0; // 静态成员初始化

void CreateProcessAndPipe(vector<ProcInfo> &PP, int ppNum = 3)
{
    vector<int> fds;    //存储继承中不需要的写端 fd
    for(int i = 0; i < ppNum; i++)
    {
        //首先创建管道
        int pipefd[2];
        int ret = pipe(pipefd);
        assert(ret != -1);
        (void)ret;

        //然后创建子进程
        int id = fork();
        assert(id != -1);
        (void)id;

        if(id == 0)
        {
            //子进程内

            //需要先关闭之前子进程遗留的写端fd
            for(auto e : fds)
                close(e);

            close(pipefd[1]);   //子进程关闭写端
            waitCommand(pipefd[0]);  //子进程等待命令

            close(pipefd[0]);
            exit(0);
        }

        //父进程内
        close(pipefd[0]);   //父进程关闭读端
        PP.push_back(ProcInfo(id, pipefd[1]));
        fds.push_back(pipefd[1]);
    }
}

3.3任务类创建及任务等待

子进程在创建完成后，需要进入一个 等待阶段 -> 读端阻塞，同时当子进程读取到相应的指令时，需要执行相应任务，这里将封装成了一个类，并通过对象调用函数

ctrlProc.cc 中

void waitCommand(int rfd)
{
    while(true)
    {
        //读端尝试读取信息
        int command = 0; 
        int n = read(rfd, &command, sizeof(command));
        if(n != 0)
        {
            TaskPools().Execute(command);
        }
        else
        {
            cout << "当前子进程读取任务失败，已退出!" << endl;
            break;
        }
    }
}

Task.hpp 中

#pragma once

#include <iostream>
#include <vector>
#include <unistd.h>

using namespace std;

void PrintLOG()
{
  cout << "PID: " << getpid() << " 正在执行打印日志的任务…" << endl;
}

void InsertSQL()
{
  cout << "PID: " << getpid() << " 正在执行数据库插入的任务…" << endl;
}

void NetRequst()
{
  cout << "PID: " << getpid() << " 正在执行网络请求的任务…" << endl;
}

typedef void(*func_t)();

//任务池
class TaskPools
{
public:
    TaskPools()
    {
    	//装载任务
        _vft.push_back(PrintLOG);
        _vft.push_back(InsertSQL);
        _vft.push_back(NetRequst);
    }

    ~TaskPools()
    {}

    void Execute(int num)
    {
        //根据编号，执行任务
        if(num < 0 || num > _vft.size())
            cout << "没有这个任务" << endl;
        else
            _vft[num]();
    }

private:
    vector<func_t> _vft;    //可用任务表
};

3.4子进程控制

当所有子进程都完成注册后（统计至 PP 中），可以让用户输入下标选择程序、输入任务编号选择任务、或者输入程序退出

注意： 因为当前子进程编号从 1 开始，所以在进行下标访问时，需要 -1 避免越界

void showTask()
{
    cout << "**************************" << endl;
    cout << "* 0.日志打印  1.数据插入 *" << endl;
    cout << "* 2.网络请求  3.退出程序 *" << endl;
    cout << "**************************" << endl;
}

void CtrlProcess(vector<ProcInfo> &PP)
{
    while (true)
    {
        // 展示当前可用的进程
        int index = 0;
        do
        {
            cout << "当前可选择进程：";
            for (int i = 1; i <= PP.size(); i++)
                cout << i << " ";
            cout << endl;

            cout << "请选择进程: ";
            cin >> index;
        } while (index < 1 || index > PP.size());

        int taskNum = 0;
        do
        {
            showTask(); // 展示可选任务
            cout << "请选择任务: ";
            cin >> taskNum;
        } while (taskNum < 0 || taskNum > 3);

        // 分配任务
        if(taskNum == 3)
            break;

        cout << "已选择： " << PP[index - 1]._num << " 号进程 | " << PP[index - 1]._name << endl;
        write(PP[index - 1]._wfd, &taskNum, sizeof(taskNum));
        sleep(1);   //执行完任务后，睡一会
    }
}

3.5子进程回收

子进程回收十分简单，因为已经在 PP 中存储了各个子进程的 PID，只需要遍历等待回收即可

void WaitProcess(vector<ProcInfo> &PP)
{
    // 遍历回收就好了
    for (auto e : PP)
    {
        close(e._wfd);  //关闭写端，读端读取到 0 自动结束阻塞
        int status = 0;
        waitpid(e._childID, &status, 0);

        // 通过 status 判断子进程运行情况
        if ((status & 0x7F))
        {
            printf("子进程异常退出，core dump: %d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
        }
        else
        {
            printf("子进程 %s 正常退出，退出码：%d\n", e._name.c_str(), (status >> 8) & 0xFF);
        }
    }

    cout << "所有子进程都已回收" << endl;
}

3.6注意事项

总体来说，在使用这个小程序时，以下关键点还是值得多注意的

注册子进程信息时，存储的是写端 fd，目的是为了通过此 fd 向对应的子进程写数据，即使用不同的匿名管道
创建管道后，需要关闭父、子进程中不必要的 fd
需要特别注意父进程写端 fd 被多次继承的问题，避免因写端没有关干净，而导致读端持续阻塞
关闭读端对应的写端后，读端会读到 0，可以借助此特性结束子进程的运行
在选择进程 / 任务时，要做好越界检查
等待子进程退出时，需要先关闭写端，子进程才会退出，然后才能正常等待

3.7完整代码

ctrlProc.cc

#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "Task.hpp" //任务所需头文件

using namespace std;

#define NAME_SIZE 64

// 封装一个包含各种必备信息的类
class ProcInfo
{
public:
    ProcInfo(pid_t id = pid_t(), int fd = int())
        : _childID(id), _wfd(fd), _num(++_count)
    {
        char buff[NAME_SIZE];
        snprintf(buff, sizeof buff, "Process %d [%d:%d]", _num, _childID, _wfd);
        _name = string(buff);
    }

    ~ProcInfo()
    {
        _childID = _wfd = 0;
    }

    pid_t _childID;    // pid
    int _wfd;          // 写端 fd
    string _name;      // 进程名
    int _num;          // 编号
    static int _count; // 计数
};

int ProcInfo::_count = 0; // 静态成员初始化

void waitCommand(int rfd)
{
    while (true)
    {
        // 读端尝试读取信息
        int command = 0;
        int n = read(rfd, &command, sizeof(command));
        if (n != 0)
        {
            TaskPools().Execute(command);
        }
        else
        {
            cout << "当前子进程读取任务失败，已退出!" << endl;
            break;
        }
    }
}

void CreateProcessAndPipe(vector<ProcInfo> &PP, int ppNum = 3)
{
    vector<int> fds; // 存储继承中不需要的写端 fd
    for (int i = 0; i < ppNum; i++)
    {
        // 首先创建管道
        int pipefd[2];
        int ret = pipe(pipefd);
        assert(ret != -1);
        (void)ret;

        // 然后创建子进程
        int id = fork();
        assert(id != -1);
        (void)id;

        if (id == 0)
        {
            // 子进程内

            // 需要先关闭之前子进程遗留的写端fd
            for (auto e : fds)
                close(e);

            close(pipefd[1]);       // 子进程关闭写端
            waitCommand(pipefd[0]); // 子进程等待命令

            close(pipefd[0]);
            exit(0);
        }

        // 父进程内
        close(pipefd[0]); // 父进程关闭读端
        PP.push_back(ProcInfo(id, pipefd[1]));
        fds.push_back(pipefd[1]);
    }
}

void showTask()
{
    cout << "**************************" << endl;
    cout << "* 0.日志打印  1.数据插入 *" << endl;
    cout << "* 2.网络请求  3.退出程序 *" << endl;
    cout << "**************************" << endl;
}

void CtrlProcess(vector<ProcInfo> &PP)
{
    while (true)
    {
        // 展示当前可用的进程
        int index = 0;
        do
        {
            cout << "当前可选择进程：";
            for (int i = 1; i <= PP.size(); i++)
                cout << i << " ";
            cout << endl;

            cout << "请选择进程: ";
            cin >> index;
        } while (index < 1 || index > PP.size());

        int taskNum = 0;
        do
        {
            showTask(); // 展示可选任务
            cout << "请选择任务: ";
            cin >> taskNum;
        } while (taskNum < 0 || taskNum > 3);

        // 分配任务
        if (taskNum == 3)
            break;

        cout << "已选择： " << PP[index - 1]._num << " 号进程 | " << PP[index - 1]._name << endl;
        write(PP[index - 1]._wfd, &taskNum, sizeof(taskNum));
        sleep(1); // 执行完任务后，睡一会
    }
}

void WaitProcess(vector<ProcInfo> &PP)
{
    // 遍历回收就好了
    for (auto e : PP)
    {
        close(e._wfd);  //关闭写端，读端读取到 0 自动结束阻塞
        int status = 0;
        waitpid(e._childID, &status, 0);

        // 通过 status 判断子进程运行情况
        if ((status & 0x7F))
        {
            printf("子进程异常退出，core dump: %d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
        }
        else
        {
            printf("子进程 %s 正常退出，退出码：%d\n", e._name.c_str(), (status >> 8) & 0xFF);
        }
    }

    cout << "所有子进程都已回收" << endl;
}

int main()
{
    // 1、创建一批进程及匿名管道
    vector<ProcInfo> PP;
    CreateProcessAndPipe(PP);

    // 2、进程控制
    CtrlProcess(PP);

    // 3、进程回收
    WaitProcess(PP);

    return 0;
}

Task.hpp

#pragma once

#include <iostream>
#include <vector>
#include <unistd.h>

using namespace std;

void PrintLOG()
{
  cout << "PID: " << getpid() << " 正在执行打印日志的任务…" << endl;
}

void InsertSQL()
{
  cout << "PID: " << getpid() << " 正在执行数据库插入的任务…" << endl;
}

void NetRequst()
{
  cout << "PID: " << getpid() << " 正在执行网络请求的任务…" << endl;
}

typedef void(*func_t)();

//任务池
class TaskPools
{
public:
    TaskPools()
    {
        _vft.push_back(PrintLOG);
        _vft.push_back(InsertSQL);
        _vft.push_back(NetRequst);
    }

    ~TaskPools()
    {}

    void Execute(int num)
    {
        //根据编号，执行任务
        if(num < 0 || num > _vft.size())
            cout << "没有这个任务" << endl;
        else
            _vft[num]();
    }

private:
    vector<func_t> _vft;    //可用任务表
};

Makefile

ctrlProc:ctrlProc.cc
	g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -r ctrlProc

养乌龟的小少年

关注

18
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
Linux进程间通信（管道）

匿名管道相关知识复盘
复制链接

扫一扫

专栏目录