Linux进程间通信——匿名管道|命名管道

目录

进程间通信介绍

进程间通信目的

 进程间通信发展

 进程间通信分类

管道(基于文件)

 System V IPC(基于本地通信,不能跨网络)

POSIX IPC 

管道 

什么是管道

匿名管道

匿名管道的原理

任何进程通信的手段

用fork来共享管道原理 

 站在文件描述符角度-深度理解管道

站在内核角度-管道本质

​编辑

pipe函数 

pipe2

 进程通信的步骤

第一步,创建管道 

第二步,创建子进程

 第三步,关闭不需要的fd

 第四步,开始通信

管道的特点

 管道的四种场景

基于匿名管道设计一个小的进程池

命名管道 

使用命令创建命名管道 

创建一个命名管道

mkfifo

mkfifo函数的返回值: 

命名管道的打开规则

 命名管道的应用——客户端和服务端的通信

 匿名管道与命名管道的区别


进程间通信介绍

进程间通信目的

数据传输:一个进程需要将它的数据发送给另一个进程

资源共享:多个进程之间共享同样的资源。

通知事件:一个进程需要向另一个或一组进程发送消息,通知它(它们)发生了某种事件(如进程终止 时要通知父进程)。

进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程),此时控制进程希望能够拦截另 一个进程的所有陷入和异常,并能够及时知道它的状态改变。

 进程间通信发展

管道

System V进程间通信

POSIX进程间通信

 进程间通信分类

管道(基于文件)

匿名管道pipe

命名管道

 System V IPC(基于本地通信,不能跨网络)

System V 消息队列

System V 共享内存

System V 信号量

POSIX IPC 

消息队列

共享内存

信号量

互斥量

条件变量

读写锁

管道 

什么是管道

管道是Unix中最古老的进程间通信的形式。 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”

Linux进程间通信——匿名管道|命名管道_第1张图片

匿名管道

匿名管道的原理

匿名管道用于进程间通信,且仅限于本地父子进程之间的通信

任何进程通信的手段

a.想办法,先让不同的进程,看到同一份资源

b.让一方写入,一方读取,完成通信过程,至于通信目的与后续工作,要结合具体场景

进程间通信的本质就是,让不同的进程看到同一份资源,使用匿名管道实现父子进程间通信的原理就是,让两个父子进程先看到同一份被打开的文件资源,然后父子进程就可以对该文件进行写入或是读取操作,进而实现父子进程间通信。 

Linux进程间通信——匿名管道|命名管道_第2张图片

——创建子进程的时候fork子进程,只会复制进程相关的数据结构对象 ,不会复制父进程曾经打开的文件对象

现象:这就是为什么fork之后,父子进程都printf,cout,都会向同一个显示器终端打印数据的原因

用fork来共享管道原理 

Linux进程间通信——匿名管道|命名管道_第3张图片

 站在文件描述符角度-深度理解管道

Linux进程间通信——匿名管道|命名管道_第4张图片

Linux进程间通信——匿名管道|命名管道_第5张图片

Linux进程间通信——匿名管道|命名管道_第6张图片

站在内核角度-管道本质
Linux进程间通信——匿名管道|命名管道_第7张图片

pipe函数 

 Linux进程间通信——匿名管道|命名管道_第8张图片

#include 
功能:创建一无名管道
原型
int pipe(int fd[2]);
参数
fd:文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0,失败返回错误代码

 Linux进程间通信——匿名管道|命名管道_第9张图片

pipe2

pipe2函数与pipe函数类似,也是用于创建匿名管道,其函数原型如下:

int pipe2(int pipefd[2], int flags);

pipe2函数的第二个参数用于设置选项。

1、当没有数据可读时:

O_NONBLOCK disable:read调用阻塞,即进程暂停执行,一直等到有数据来为止。
O_NONBLOCK enable:read调用返回-1,errno值为EAGAIN。
2、当管道满的时候:

O_NONBLOCK disable:write调用阻塞,直到有进程读走数据。
O_NONBLOCK enable:write调用返回-1,errno值为EAGAIN。
3、如果所有管道写端对应的文件描述符被关闭,则read返回0。
4、如果所有管道读端对应的文件描述符被关闭,则write操作会产生信号SIGPIPE,进而可能导致write进程退出。
5、当要写入的数据量不大于PIPE_BUF时,Linux将保证写入的原子性。
6、当要写入的数据量大于PIPE_BUF时,Linux将不再保证写入的原子性。

 进程通信的步骤

 用管道通信,大致分为四个步骤

Linux进程间通信——匿名管道|命名管道_第10张图片

第一步,创建管道 

查看一下管道文件是否创建成功

Linux进程间通信——匿名管道|命名管道_第11张图片

第二步,创建子进程

Linux进程间通信——匿名管道|命名管道_第12张图片

 第三步,关闭不需要的fd

 我们一般把pipefd[0]作为读端,pipefd[1]作为写端——0对应嘴巴用来读,1对应笔用来写

 Linux进程间通信——匿名管道|命名管道_第13张图片

 第四步,开始通信

Linux进程间通信——匿名管道|命名管道_第14张图片

 Linux进程间通信——匿名管道|命名管道_第15张图片

#include 
#include 
#include 
#include 
#include 
#include 
#include 
int main()
{
// 让不同的进程看到同一份资源!!!!
    // 任何一种任何一种进程间通信中,一定要 先 保证不同的进程之间看到同一份资源
    int pipefd[2] = {0};
    //1. 创建管道
    int n = pipe(pipefd);
    if(n < 0)
    {
        std::cout << "pipe error, " << errno << ": " << strerror(errno) << std::endl;
        return 1;
    }
    std::cout << "pipefd[0]: " << pipefd[0] << std::endl; // 读端, 0->嘴巴->读书
    std::cout << "pipefd[1]: " << pipefd[1] << std::endl; // 写端, 1->笔->写东西的

    //2. 创建子进程
    pid_t id = fork();
    assert(id != -1); //正常应该用判断,我这里就断言:意料之外用if,意料之中用assert

    if(id == 0)// 子进程
    {
        //3. 关闭不需要的fd,让父进程进行读取,让子进程进行写入
        close(pipefd[0]);

        //4. 开始通信 -- 结合某种场景
        const std::string namestr = "hello ,我是子进程";
        int cnt = 1;
        char buffer[1024];
        while(true)
        {
            snprintf(buffer, sizeof buffer, "%s, 计数器: %d, 我的PID: %d\n", namestr.c_str(), cnt++, getpid());
            write(pipefd[1], buffer, strlen(buffer));
            sleep(1);
        }

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

    //父进程
    //3. 关闭不需要的fd,让父进程进行读取,让子进程进行写入
    close(pipefd[1]);

    //4. 开始通信 -- 结合某种场景
    char buffer[1024];
    while(true)
    {
        int n = read(pipefd[0], buffer, sizeof(buffer) - 1);
        if(n > 0)
        {
            buffer[n] = '\0';
            std::cout << "我是父进程, child give me message: " << buffer << std::endl;
        }

    }
    close(pipefd[0]);

    return 0;

}

 Linux进程间通信——匿名管道|命名管道_第16张图片

 这要一个简单的管道通信就写好了

这里有一个细节,在子进程写的时候每写一次sleep一秒

管道的特点

1.单向通信

2.管道的本质是文件,因为fd的生命周期随进程,管道的生命周期是随进程的

3.管道通信,通常用来进行具有“血缘”关系的进程,进行进程间通信。常用与父子通信——pipe打开管道,并不清楚管道的名字,匿名管道

4.在管道通信中,写入的次数,和读取的次数不是严格匹配的,读写次数的多少没有强相关--表现--字节流

5.具有一定的协同能力,让reader和writer能够按照一定的步骤进行通信--自带同步机制

 管道的四种场景

1.如果我们read读取完毕了所有的管道数据,如果对方不发,我们只能等待

2.如果我们write端将管道写满了,我们还能写吗?不能

3.如果我关闭了写端,读取完毕管道数据,再读,就会read返回0,表明读到了文件结尾

4.写端一直写,读端关闭,会发生什么呢?没有意义OS不会维护无意义,低效率,或者浪费资源的事情。OS会杀死一直在写入的进程!OS会通过信号来终止进程   13)SIGPIPE

基于匿名管道设计一个小的进程池

父进程向子进程写入特定的消息,唤醒子进程,甚至让子进程定向的执行某周任务

Linux进程间通信——匿名管道|命名管道_第17张图片

 创建进程部分

void createProcesses(vector *end_points)
{
    vector fds;
    for (int i = 0; i < gnum; i++)
    {
        // 1.1 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        assert(n == 0);
        (void)n;

        // 1.2 创建进程
        pid_t id = fork();
        assert(id != -1);
        // 一定是子进程
        if (id == 0)
        {
            for(auto &fd : fds) close(fd);

            // std::cout << getpid() << " 子进程关闭父进程对应的写端:";
            // for(auto &fd : fds)
            // {
            //     std::cout << fd << " ";
            //     close(fd);
            // }
            // std::cout << std::endl;
            
            // 1.3 关闭不要的fd
            close(pipefd[1]);
            // 我们期望,所有的子进程读取"指令"的时候,都从标准输入读取
            // 1.3.1 输入重定向,可以不做
            dup2(pipefd[0], 0);
            // 1.3.2 子进程开始等待获取命令
            WaitCommand();
            close(pipefd[0]);
            exit(0);
        }

        // 一定是父进程
        //  1.3 关闭不要的fd
        close(pipefd[0]);

        // 1.4 将新的子进程和他的管道写端,构建对象
        end_points->push_back(EndPoint(id, pipefd[1]));

        fds.push_back(pipefd[1]);
    }
}

在创建管道for循环中,在下一次循环管道的文件描述符会覆盖掉,作为父进程怎么知道哪一个进程对应哪一个管道呢?

所以定义一个类(或者结构体)来管理创建创建出来的子进程和管道,先描述在组织,

父进程需要的是有哪些子进程,哪些管道,子进程和管道的关系

再用一个vector容器来管理所有这个类

class EndPoint
{
public:
    pid_t _child_id;//子进程的pid
    int _write_fd;//向哪一个管道里写

public:
    EndPoint(int id, int fd) : _child_id(id), _write_fd(fd)
    {
    }
    ~EndPoint()
    {
    }
};

子进程要执行的方法

void WaitCommand()
{
    while (true)
    {
        int command = 0;
        int n = read(0, &command, sizeof(int));
        if (n == sizeof(int))
        {
            t.Execute(command);
        }
        else if (n == 0)
        {
            std::cout << "父进程让我退出,我就退出了: " << getpid() << std::endl; 
            break;
        }
        else
        {
            break;
        }
    }
}

 总代码

Task.hpp

#pragma once

#include 
#include 
#include 

// typedef std::function func_t;

typedef void (*fun_t)(); //函数指针

void PrintLog()
{
    std::cout << "pid: "<< getpid() << ", 打印日志任务,正在被执行..." << std::endl;
}

void InsertMySQL()
{
    std::cout << "执行数据库任务,正在被执行..." << std::endl;
}

void NetRequest()
{
    std::cout << "执行网络请求任务,正在被执行..." << std::endl;
}

//约定,每一个command都必须是4字节
#define COMMAND_LOG 0
#define COMMAND_MYSQL 1
#define COMMAND_REQEUST 2

class Task
{
public:
    Task()
    {
        funcs.push_back(PrintLog);
        funcs.push_back(InsertMySQL);
        funcs.push_back(NetRequest);
    }
    void Execute(int command)
    {
        if(command >= 0 && command < funcs.size()) funcs[command]();
    }
    ~Task()
    {}
public:
    std::vector funcs;
};





 ctrlProcess.cc

#include 
#include 
#include 
#include 
#include 
#include "Task.hpp"
using namespace std;

const int gnum = 5;//表示未来一共想要创建几个子进程
Task t;

class EndPoint
{
public:
    pid_t _child_id;
    int _write_fd;

public:
    EndPoint(int id, int fd) : _child_id(id), _write_fd(fd)
    {
    }
    ~EndPoint()
    {
    }
};

// 子进程要执行的方法
void WaitCommand()
{
    while (true)
    {
        int command = 0;
        int n = read(0, &command, sizeof(int));
        if (n == sizeof(int))
        {
            t.Execute(command);
        }
        else if (n == 0)
        {
            break;
        }
        else
        {
            break;
        }
    }
}

void createProcesses(vector *end_points)
{
    for (int i = 0; i < gnum; i++)
    {
        // 1.1 创建管道
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        assert(n == 0);
        (void)n;

        // 1.2 创建进程
        pid_t id = fork();
        assert(id != -1);
        // 一定是子进程
        if (id == 0)
        {
            // 1.3 关闭不要的fd
            close(pipefd[1]);
            // 我们期望,所有的子进程读取"指令"的时候,都从标准输入读取
            // 1.3.1 输入重定向
            dup2(pipefd[0], 0);
            // 1.3.2 子进程开始等待获取命令
            WaitCommand();
            close(pipefd[0]);
            exit(0);
        }

        // 一定是父进程
        //  1.3 关闭不要的fd
        close(pipefd[0]);

        // 1.4 将新的子进程和他的管道写端,构建对象
        end_points->push_back(EndPoint(id, pipefd[1]));
    }
}

int main()
{
    // 1. 先进行构建控制结构, 父进程写入,子进程读取 , bug?
    vector end_points;
    createProcesses(&end_points);
    // 2. 我们的得到了什么?end_points
    int num = 0;
    while(true)
    {
        //1. 选择任务
        int command = COMMAND_LOG;

        //2. 选择进程
        int index = rand()%end_points.size();

        //3. 下发任务
        write(end_points[index]._write_fd, &command, sizeof(command));

        sleep(1);
    }
    return 0;
}

 Linux进程间通信——匿名管道|命名管道_第18张图片

匿名管道只能用于具有血缘关系的进程,如父子进程来进行进程间通信,如果我想要让毫不相干的两个进程来进程通信呢?——这里就可以用到命名管道了

----------------------------------------------------

命名管道 

管道应用的一个限制就是只能在具有共同祖先(具有亲缘关系)的进程间通信。

如果我们想在不相关的进程之间交换数据,可以使用FIFO文件来做这项工作,它经常被称为命名管道。

命名管道是一种特殊类型的文件

使用命令创建命名管道 

 我们可以使用mkfifo命令创建一个命名管道。

Linux进程间通信——匿名管道|命名管道_第19张图片

这里我从另一端输入,从另一端读取,这就证明了这两个毫不相关的进程可以通过命名管道进行数据传输,即通信。

Linux进程间通信——匿名管道|命名管道_第20张图片

 如果两个不相干的进程打开同一个文件,要不要再打开一个stuct file 结构体?

答案是不用,操作系统只会将指向改文件的引用计数ret加一

而且用管道文件写入读取不会进行刷盘,也没有对应的data block

如何保证两个毫不相关的进程,看到的是同一个文件并打开?

文件是有唯一性的,用路径表示

让不同的进程通过文件路径+文件名看到同一个文件,并打开——就是看到了同一资源——具备了进程间通信的前提

创建一个命名管道

命名管道可以从命令行上创建,命令行方法是使用下面这个命令:

mkfifo filename

命名管道也可以从程序里创建,相关函数有:

mkfifo

Linux进程间通信——匿名管道|命名管道_第21张图片

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

mkfifo函数的第一个参数是pathname,表示要创建的命名管道文件

mkfifo函数的第二个参数是mode,表示创建命名管道文件的默认权限

若想创建出来命名管道文件的权限值不受umask的影响,则需要在创建文件前使用umask函数将文件默认掩码设置为0

umask(0); //将文件默认掩码设置为0
mkfifo函数的返回值: 

命名管道创建成功,返回0。

命名管道创建失败,返回-1。

命名管道的打开规则

1、如果当前打开操作是为读而打开FIFO时

O_NONBLOCK disable:阻塞直到有相应进程为写而打开该FIFO。
O_NONBLOCK enable:立刻返回成功。
2、如果当前打开操作是为写而打开FIFO时

O_NONBLOCK disable:阻塞直到有相应进程为读而打开该FIFO。
O_NONBLOCK enable:立刻返回失败,错误码为ENXIO。

Linux进程间通信——匿名管道|命名管道_第22张图片

Linux进程间通信——匿名管道|命名管道_第23张图片

注意这里的权限变成了664,但是我给的权限是666,这里是因为没有设置权限掩码

再重新创建文件

Linux进程间通信——匿名管道|命名管道_第24张图片

 命名管道的应用——客户端和服务端的通信

服务端

第一步,创建管道

Linux进程间通信——匿名管道|命名管道_第25张图片

第二步,让服务端直接开启管道文件

Linux进程间通信——匿名管道|命名管道_第26张图片

 第三步,正常通信

Linux进程间通信——匿名管道|命名管道_第27张图片

第四步,关闭不需要的fd 

客户端

Linux进程间通信——匿名管道|命名管道_第28张图片

打开服务端,会发现server会卡在这里,原因客户端没有打开命名管道而导致的阻塞

 

继续打开客户端

这里简单的通信就做好了,但是这里服务端退出并不会自动把管道文件删除,在下次启动的时候就会报错,所以要对这里进行一些优化,用unlink函数

Linux进程间通信——匿名管道|命名管道_第29张图片

这里直接给出最后的全部代码(不用回车就能实现字符输入)

client.cc

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
// #include 
#include "comm.hpp"

int main()
{
    //1. 不需创建管道文件,我只需要打开对应的文件即可!
    int wfd = open(fifoname.c_str(), O_WRONLY);
    if(wfd < 0)
    {
        std::cerr << errno << ":" << strerror(errno) << std::endl;
        return 1;
    }

    // 可以进行常规通信了
    char buffer[NUM];
    while(true)
    {
        // std::cout << "请输入你的消息# ";
        // char *msg = fgets(buffer, sizeof(buffer), stdin);
        // assert(msg);
        // (void)msg;
        // int c = getch();
        // std::cout << c << std::endl;
        // if(c == -1) continue;

        system("stty raw");
        int c = getchar();
        system("stty -raw");

        //std::cout << c << std::endl;
        //sleep(1);

        //buffer[strlen(buffer) - 1] = 0;
        // abcde\n\0
        // 012345
        //if(strcasecmp(buffer, "quit") == 0) break;

        ssize_t n = write(wfd, (char*)&c, sizeof(char));
        assert(n >= 0);
        (void)n;
    }

    close(wfd);

    return 0;
}

server.cc

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "comm.hpp"

//少年们, 我刚刚写了一个基于匿名管道的进程池
// 可不可以把它改成使用命名管道呢??
int main()
{
    // 1. 创建管道文件,我们今天只需要一次创建
    umask(0); //这个设置并不影响系统的默认配置,只会影响当前进程
    int n = mkfifo(fifoname.c_str(), mode);
    if(n != 0)
    {
        std::cout << errno << " : " << strerror(errno) << std::endl;
        return 1;
    }
    std::cout << "create fifo file success" << std::endl;
    // 2. 让服务端直接开启管道文件
    int rfd = open(fifoname.c_str(), O_RDONLY);
    if(rfd < 0 )
    {
        std::cout << errno << " : " << strerror(errno) << std::endl;
        return 2;
    }
    std::cout << "open fifo success, begin ipc" << std::endl;

    // 3. 正常通信
    char buffer[NUM];
    while(true)
    {
        buffer[0] = 0;
        ssize_t n = read(rfd, buffer, sizeof(buffer) - 1);
        if(n > 0)
        {
            buffer[n] = 0;
            //std::cout << "client# " << buffer << std::endl;
            printf("%c", buffer[0]);
            fflush(stdout);
        }
        else if(n == 0)
        {
            std::cout << "client quit, me too" << std::endl;
            break;
        }
        else 
        {
            std::cout << errno << " : " << strerror(errno) << std::endl;
            break;
        }
    }

    // 关闭不要的fd
    close(rfd);

    unlink(fifoname.c_str());

    return 0;
}

comm.hpp

#pragma once

#include 
#include 

#define NUM 1024

const std::string fifoname = "./fifo";
uint32_t mode = 0666; 

 服务端和客户端之间的退出关系

当客户端退出后,服务端将管道当中的数据读完后就再也读不到数据了,那么此时服务端也就会去执行它的其他代码了(在当前代码中是直接退出了)。

当服务端退出后,客户端写入管道的数据就不会被读取了,也就没有意义了,那么当客户端下一次再向管道写入数据时,就会收到操作系统发来的13号信号(SIGPIPE),此时客户端就被操作系统强制杀掉了。

 匿名管道与命名管道的区别

匿名管道由pipe函数创建并打开

命名管道由mkfifo函数创建打开用open

FIFO(命名管道)与pipe(匿名管道)之间唯一的区别在它们创建与打开的方式不同,一但这些工作完 成之后,它们具有相同的语义

你可能感兴趣的:(Linux笔记,linux,服务器,运维)