Linux进程通信之管道通信

我们都知道,进程之间都是相互独立的,为了实现进程间能够互相传输数据便有了进程间通信。进程间通信分为三类,第一类是基于文件系统的管道通信,第二类是基于system v标准的本地通信,第三类是基于POSIX标准,能够实现跨主机的通信。今天我们所要探讨的是第一大类管道通信。在认识管道通信之前,我们得先知道什么是管道。

管道的概念

我们拿自来水管道来举例,自来水管道里面的水从一头流向另一头。在计算机世界里,管道的两端是两个进程,水流就相当于两个进程之间传输的数据。那这个管道到底是什么呢?我们用一张图来表示它:

Linux进程通信之管道通信_第1张图片

管道是属于内核的,所以os为我们提供了创建管道的系统调用,这个我们后面再讲。现在我们来谈一谈为什么要使用管道这个东西。

有人就有疑问,管道是基于文件系统的内存级文件,这句话是怎么理解的?

在解答这个问题之前,我们思考一下,如果想基于文件系统实现两个进程的通信很简单:在磁盘中创建一个文件,一个进程写,文件先被加载到内存中再将数据写到文件中最后定期刷新到磁盘上。一个进程读,将文件加载到内存中,再从内存中读取数据。文件的IO大大降低了进程间的通信效率。所以管道是基于文件系统的,目的是和别的文件一样可以进行读写。管道也是一个内存级文件,原因就在于它是被创建在内存里的,各个进程进行数据的传输只需要和内存打交道,和磁盘无关,提高了数据通信的效率。

匿名管道

管道分为匿名管道命名管道。当我们一个进程通过系统调用创建出一个管道时,因为管道是一个基于文件系统的内存级文件。所以打开这个文件时,进程的文件描述符表就存有该文件的描述符。该文件有两个描述符,一个是读端描述符,一个是写端描述符:

Linux进程通信之管道通信_第2张图片

可是进程与进程之间是相互独立的,那么如何让另一个进程看到这个管道呢?我们可以通过fork创建子进程的方式,这样子进程就继承了父进程的文件描述符表,通过文件描述符表就可以找到同一个管道了:

Linux进程通信之管道通信_第3张图片

 为了让两个进程各个执行自己的读写任务,我们可以关闭它们任务除外的文件描述符:

Linux进程通信之管道通信_第4张图片

所以我们称有血缘关系间的进程通信所使用的管道为匿名管道。它的系统调用接口是pipe:

Linux进程通信之管道通信_第5张图片

 pipefd 数组里存放的是管道的读写文件描述符,pipefd[0]是读端描述符,pipefd[1]是写端描述符。现在我们就尝试实现父子进程之间的通信:


#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

// 父进程进行读取,子进程进行写入
int main()
{
    // 第一步:创建管道文件,打开读写端
    int fds[2];
    int n = pipe(fds);
    assert(n == 0);

    // 第二步: fork
    pid_t id = fork();
    assert(id >= 0);
    if (id == 0)
    {
        // 子进程进行写入
        close(fds[0]);
        // 子进程的通信代码
        // string msg = "hello , i am child";
        const char *s = "我是子进程,我正在给你发消息";
        int cnt = 0;
        while (true)
        {
            cnt++;
            char buffer[1024]; // 只有子进程能看到!
            snprintf(buffer, sizeof buffer, "child->parent say: %s[%d][%d]", s, cnt, getpid());
            // 写端写满的时候,在写会阻塞,等对方进行读取!
            write(fds[1], buffer, strlen(buffer));
            cout << "count: " << cnt << endl;
            // sleep(50); //细节,我每隔1s写一次
            // break;
        }

        // 子进程
        close(fds[1]); // 子进程关闭写端fd
        cout << "子进程关闭自己的写端" << endl;
        // sleep(10000);
        exit(0);
    }
    // 父进程进行读取
    close(fds[1]);
    // 父进程的通信代码
    while (true)
    {
        sleep(2);
        char buffer[1024];
        // cout << "AAAAAAAAAAAAAAAAAAAAAA" << endl;
        // 如果管道中没有了数据,读端在读,默认会直接阻塞当前正在读取的进程!
        ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);
        // cout << "BBBBBBBBBBBBBBBBBBBBBB" << endl;
        if (s > 0)
        {
            buffer[s] = 0;
            cout << "Get Message# " << buffer << " | my pid: " << getpid() << endl;
        }
        else if(s == 0)
        {
            //读到文件结尾
            cout << "read: " << s << endl;
            break;
        }
        break;

        // 细节:父进程可没有进行sleep
        // sleep(5);
    }
    close(fds[0]);
    cout << "父进程关闭读端" << endl;

    int status = 0;
    n = waitpid(id, &status, 0);
    assert(n == id);

    cout <<"pid->"<< n << " : "<< (status & 0x7F) << endl;

    return 0;
}

管道的读写规则:

当没有数据可读时:
O_NONBLOCK disable read 调用阻塞,即进程暂停执行,一直等到有数据来到为止。
O_NONBLOCK enable read 调用返回 -1 errno 值为 EAGAIN
当管道满的时候:
O_NONBLOCK disable write 调用阻塞,直到有进程读走数据
O_NONBLOCK enable :调用返回 -1 errno 值为 EAGAIN
如果所有管道写端对应的文件描述符被关闭,则 read 返回 0
如果所有管道读端对应的文件描述符被关闭,则 write 操作会产生信号 SIGPIPE, 进而可能导致 write进程收到信号被杀死

用匿名管道实现进程池:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define MakeSeed() srand((unsigned long)time(nullptr) ^ getpid() ^ 0x171237 ^ rand() % 1234)

#define PROCSS_NUM 10

///子进程要完成的某种任务 -- 模拟一下/
// 函数指针 类型
typedef void (*func_t)();

void downLoadTask()
{
    std::cout << getpid() << ": 下载任务\n"
              << std::endl;
    sleep(1);
}

void ioTask()
{
    std::cout << getpid() << ": IO任务\n"
              << std::endl;
    sleep(1);
}

void flushTask()
{
    std::cout << getpid() << ": 刷新任务\n"
              << std::endl;
    sleep(1);
}

void loadTaskFunc(std::vector *out)
{
    assert(out);
    out->push_back(downLoadTask);
    out->push_back(ioTask);
    out->push_back(flushTask);
}

/下面的代码是一个多进程程序//
class subEp // Endpoint
{
public:
    subEp(pid_t subId, int writeFd)
        : subId_(subId), writeFd_(writeFd)
    {
        char nameBuffer[1024];
        snprintf(nameBuffer, sizeof nameBuffer, "process-%d[pid(%d)-fd(%d)]", num++, subId_, writeFd_);
        name_ = nameBuffer;
    }

public:
    static int num;
    std::string name_;
    pid_t subId_;
    int writeFd_;
};

int subEp::num = 0;

int recvTask(int readFd)
{
    int code = 0;
    ssize_t s = read(readFd, &code, sizeof code);
    if(s == 4) return code;
    else if(s <= 0) return -1;
    else return 0;
}

void sendTask(const subEp &process, int taskNum)
{
    std::cout << "send task num: " << taskNum << " send to -> " << process.name_ << std::endl;
    int n = write(process.writeFd_, &taskNum, sizeof(taskNum));
    assert(n == sizeof(int));
    (void)n;
}

void createSubProcess(std::vector *subs, std::vector &funcMap)
{
    std::vector deleteFd;
    for (int i = 0; i < PROCSS_NUM; i++)
    {
        int fds[2];
        int n = pipe(fds);
        assert(n == 0);
        (void)n;
        // 父进程打开的文件,是会被子进程共享的
        // 你试着多想几轮
        pid_t id = fork();
        if (id == 0)
        {
            for(int i = 0; i < deleteFd.size(); i++) close(deleteFd[i]);
            // 子进程, 进行处理任务
            close(fds[1]);
            while (true)
            {
                // 1. 获取命令码,如果没有发送,我们子进程应该阻塞
                int commandCode = recvTask(fds[0]);
                // 2. 完成任务
                if (commandCode >= 0 && commandCode < funcMap.size())
                    funcMap[commandCode]();
                else if(commandCode == -1) break;
            }
            exit(0);
        }
        close(fds[0]);
        subEp sub(id, fds[1]);
        subs->push_back(sub);
        deleteFd.push_back(fds[1]);
    }
}

void loadBlanceContrl(const std::vector &subs, const std::vector &funcMap, int count)
{
    int processnum = subs.size();
    int tasknum = funcMap.size();
    bool forever = (count == 0 ? true : false);

    while (true)
    {
        // 1. 选择一个子进程 --> std::vector -> index - 随机数
        int subIdx = rand() % processnum;
        // 2. 选择一个任务 --> std::vector -> index
        int taskIdx = rand() % tasknum;
        // 3. 任务发送给选择的进程
        sendTask(subs[subIdx], taskIdx);
        sleep(1);
        if(!forever)
        {
            count--;
            if(count == 0) break;   
        }
    }
    // write quit -> read 0
    for(int i = 0; i < processnum; i++) close(subs[i].writeFd_); // waitpid();
}

    
void waitProcess(std::vector processes)
{
    int processnum = processes.size();
    for(int i = 0; i < processnum; i++)
    {
        waitpid(processes[i].subId_, nullptr, 0);
        std::cout << "wait sub process success ...: " << processes[i].subId_ << std::endl;
    }
}

int main()
{
    MakeSeed();
    // 1. 建立子进程并建立和子进程通信的信道, 有bug的,但是不影响我们后面编写
    // 1.1 加载方发表
    std::vector funcMap;
    loadTaskFunc(&funcMap);
    // 1.2 创建子进程,并且维护好父子通信信道
    std::vector subs;
    createSubProcess(&subs, funcMap);

    // 2. 走到这里就是父进程, 控制子进程,负载均衡的向子进程发送命令码
    int taskCnt = 3; // 0: 永远进行
    loadBlanceContrl(subs, funcMap, taskCnt);

    // 3. 回收子进程信息
    waitProcess(subs);

    return 0;
}

进程池的代码有一点难度,需要自己实现并加以理解,这里我们就不多说了。现在我为大家讲一讲不用基于血缘关系通信的管道:命名管道。

命名管道:

可以应用于两个毫无关系的进程进行通信(没有血缘关系),调用fifo接口创建一个管道文件。我们称该管道为命名管道。命名管道是一个特殊类型的文件。

创建命名管道的接口:

int mkfifo(const char *filename,mode_t mode);
mode是权限,例如我们这是0600,这样只有使用者可以使用这个管道文件了。
通过命名管道,我们可以实现一个,客户端和服务器之间的通信:
comm.hpp:
#pragma once

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define NAMED_PIPE "/tmp/mypipe.106"

bool createFifo(const std::string &path)
{
    umask(0);
    int n = mkfifo(path.c_str(), 0600);
    if (n == 0)
        return true;
    else
    {
        std::cout << "errno: " << errno << " err string: " << strerror(errno) << std::endl;
        return false;
    }
}

void removeFifo(const std::string &path)
{
    int n = unlink(path.c_str());
    assert(n == 0); // debug , release 里面就没有了
    (void)n;
}

client.cc:

#include "comm.hpp"

// 你可不可以把刚刚写的改成命名管道呢!
int main()
{
    std::cout << "client begin" << std::endl;
    int wfd = open(NAMED_PIPE, O_WRONLY);
    std::cout << "client end" << std::endl;
    if(wfd < 0) exit(1); 

    //write
    char buffer[1024];
    while(true)
    {
        std::cout << "Please Say# ";
        fgets(buffer, sizeof(buffer), stdin); // abcd\n
        if(strlen(buffer) > 0) buffer[strlen(buffer)-1] = 0;
        ssize_t n = write(wfd, buffer, strlen(buffer));
        assert(n == strlen(buffer));
        (void)n;
    }

    close(wfd);
    return 0;
}

server.cc:

#include "comm.hpp"

int main()
{
    bool r = createFifo(NAMED_PIPE);
    assert(r);
    (void)r;

    std::cout << "server begin" << std::endl;
    int rfd = open(NAMED_PIPE, O_RDONLY);
    std::cout << "server end" << std::endl;
    if(rfd < 0) exit(1);

    //read
    char buffer[1024];
    while(true)
    {
        ssize_t s = read(rfd, buffer, sizeof(buffer)-1);
        if(s > 0)
        {
            buffer[s] = 0;
            std::cout << "client->server# " << buffer << std::endl;
        }
        else if(s == 0)
        {
            std::cout << "client quit, me too!" << std::endl;
            break;
        }
        else
        {
            std::cout << "err string: " << strerror(errno) << std::endl;
            break;
        }
    }

    close(rfd);

    // sleep(10);
    removeFifo(NAMED_PIPE);
    return 0;
}

匿名管道和命名管道的区别:

1.匿名管道由 pipe 函数创建并打开。 命名管道由mkfififo 函数创建,打开用 open
2.FIFO (命名管道)与 pipe (匿名管道)之间唯一的区别在它们创建与打开的方式不同,一但这些工作完成之后,它们具有相同的语义。

命名管道的打开规则

如果当前打开操作是为读而打开 FIFO
O_NONBLOCK disable :阻塞直到有相应进程为写而打开该 FIFO
O_NONBLOCK enable :立刻返回成功
如果当前打开操作是为写而打开 FIFO
O_NONBLOCK disable :阻塞直到有相应进程为读而打开该 FIFO O_NONBLOCK enable:立刻返回失败,错误码为 ENXIO

到这里进程间通信之管道通信就全部结束了,希望大家多多支持,共同进步! 

你可能感兴趣的:(linux,网络,运维)