[Linux]进程间通信（上篇）——匿名管道（管道原理，实现示例，端口情况探究！！）

最新推荐文章于 2024-09-16 17:22:40 发布

bang___bang_

最新推荐文章于 2024-09-16 17:22:40 发布

阅读量2.5k

点赞数 44

分类专栏：我在地球学Linux 文章标签： linux 运维服务器进程间通信匿名管道

本文链接：https://blog.csdn.net/bang___bang_/article/details/132128822

版权

我在地球学Linux 专栏收录该内容

11 篇文章 2 订阅

订阅专栏

hello，大家好，本篇文章介绍Linux进程间的通信，包含内容有进程间通信的介绍、理解，管道的介绍使用：匿名管道，匿名管道的实现示例，匿名管道端口4种情况的探究。

1️⃣进程间通信

🍙进程间通信目的

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

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

⭐ 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。

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

🍙进程间通信分类

🍘管道

匿名管道pipe
命名管道

🍘System V IPC

System V 消息队列
System V 共享内存
System V 信号量

🍘POSIX IPC

消息队列
共享内存
信号量
互斥量
条件变量
读写锁

本篇文章只介绍管道和部分System V IPC

🍙进程间通信的技术背景及必要性

✦进程具有独立性的。虚拟地址空间+页表保证进程运行的独立性（进程内核数据结构+进程的代码和数据）

✦通信成本会比较高！（因为进程独立性很强！）

🍣必要性：

单进程无法使用进程间的并发能力！无法实现多进程之间的协同工作！所以需要进程间通信来使得多进程进行协同（进程间通信不是手段，是目的！）

🍙进程间通信的本质理解

进程间通信的本质：先让不同的进程看到同一份资源（内存空间）

★进程间通信的前提，首先需要让不同的进程看到同一块资源（特定的结构组织的)

★所以所谓的进程看到同一块资源，属于哪一个进程呢？不能隶属于任何一个进程，而应该更强调共享。

2️⃣管道

🍙什么是管道

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

生活中我们见过的管道有：水管、石油管道、天然气管道等等。

在Linux中也有管道，我们把这种将资源从一端送到另一端的数据流称为管道！！

特点：只能单向通信（半双工），传输的都是资源 -->数据！

🍙匿名管道

如果你使用过Linux的命令，那么对于管道这个名词你一定不会感觉到陌生，因为我们通常通过符号“|"来使用管道，但是管理的真正定义是什么呢？管道是一个进程连接数据流到另一个进程的通道，它通常是用作把一个进程的输出通过管道连接到另一个进程的输入。

🌰在shell中输入命令：ls -l | grep my，我们知道ls命令（其实也是一个进程）会把当前目录中的文件都列出来，但是它不会直接输出，而是把本来要输出到屏幕上的数据通过管道输出到grep这个进程中，作为grep这个进程的输入，然后这个进程对输入的信息进行筛选，把存在my的信息的字符串（以行为单位）打印在屏幕上。

🍥匿名管道原理

通过父子进程继承关系，再将文件描述符关闭，实现一端写，一端读，就是匿名管道。

1.父进程以读写方式打开文件。父进程fork创建子进程，（进程具有独立性）子进程要拷贝一份PCB结构，PCB中包含了files_struct结构,files_struct中有一个指向struct file（文件）的指针数组，而文件描述符就是这个数组的下标。

2.在拷贝后，子进程也就有了指向struct file（文件）的对应数组元素下标（文件描述符）。

3.而struct file（文件）是独属于文件的，和进程没有关系，也就不用拷贝，也就是说此时父子进程公共区域就是 struct file。（实现不同进程看到同一份资源）

4.write是系统调用接口，会将数据放在内核缓冲区，底层定期刷新缓冲区将内容写到磁盘。

5.为了实现半双工的通信方式，一端读，一端写，关闭父子进程不需要的文件描述符。

🍥匿名管道创建pipe

int pipe(pipefd[2]);
参数：(输出型参数，通过参数找到打开的2个fd)文件描述符数组，其中pipefd[0]表示读端，pipefd[1]表示写端

返回值：成功返回0，失败返回错误码。

🍥匿名管道四种情况探究

🌰匿名管道实例:（子进程读取，父进程写入）

#include<iostream>
#include<unistd.h>
#include<assert.h>
#include<string>
#include<cstring>
#include<cstdio>
#include<sys/wait.h>
#include<sys/types.h>
using namespace std;

int main()
{
    //1.创建管道
    int pipefd[2]={0};//pipefd[0]:读端，pipefd[1]:写端
    int n=pipe(pipefd);
    assert(n!=-1);
    (void)n;//debug下assert有效，release下assert无效。只定义不使用n容易报警告

#ifdef DEBUG
    cout<<"pipefd[0]:"<<pipefd[0]<<endl;//3
    cout<<"pipefd[1]:"<<pipefd[1]<<endl;//4
#endif
    //2.创建子进程
    pid_t id=fork();
    assert(id!=-1);
    if(id==0)
    {
        //子进程
        //3.构建单向通信的信道,父进程写入,子进程读取
        //3.1关闭子进程不需要的fd
        close(pipefd[1]);
        char buffer[1024];
        while(true)
        {
            ssize_t s=read(pipefd[0],buffer,sizeof(buffer)-1);
            if(s>0)
            {
                buffer[s]=0;//手动添加/0
                cout<<"我是子进程["<<getpid()<<"]Father#"<<buffer<<endl;   
            }
        }
        
        exit(0);
    }
    //父进程
    //3.构建单向通信的信道
    //3.1关闭父进程不需要的fd
    close(pipefd[0]);
    string message="我是父进程，我正在给你发消息";
    int count=0;
    char send_buffer[1024];
    while(true)
    {
        //3.2构建一个变化的字符串
        snprintf(send_buffer,sizeof(send_buffer),"%s[%d]:%d",message.c_str(),getpid(),count++);
        //3.3写入
        write(pipefd[1],send_buffer,strlen(send_buffer));
        //3.4故意sleep
        sleep(1);
    }
    pid_t res=waitpid(id,nullptr,0);
    assert(res>0);
    (void)res;
    close(pipefd[1]);
    return 0;
}

A.写快，读慢，会发生什么?（我们修改代码，将子进程读端sleep(5)，父进程添加一行打印send_buffer信息）

//添加父进程打印代码
//3.2构建一个变化的字符串      
snprintf(send_buffer,sizeof(send_buffer),"%s[%d]:%d",message.c_str(),getpid(),count++);
//3.3写入
write(pipefd[1],send_buffer,strlen(send_buffer));

printf("%s\n",send_buffer);

我们可以看到一瞬间父进程写满了，然后阻塞等待子进程读取。

B.写慢，读快，会发生什么？（父进程sleep(5)，子进程不休眠）

我们可以看到，父进程在写入第一条信息后被子进程立刻读取，然后父进程休眠5s，子进程在这期间阻塞等待父进程继续写入。

C.写端关闭，读端继续，会发生什么？（父进程关闭pipefd[1]，即关闭写端，子进程修改代码显示read返回值不大于0的情况）

while(true)
        {
            ssize_t s=read(pipefd[0],buffer,sizeof(buffer)-1);
            if(s>0)
            {
                buffer[s]=0;//手动添加/0
                cout<<"我是子进程["<<getpid()<<"]Father#"<<buffer<<endl;   
            }
            else 
            {
                cout<<s<<endl;
            }
            sleep(1);
        }

结果显示：read返回0，read系统调用接口返回0即表示读取到文件结尾。

D.读端关闭，写端继续，会发生什么？（我们让子进程写数据，父进程读数据，读3次后关闭读端，此时父子进程读端都关闭）

#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <string>
#include <cstring>
#include <cassert>
int main()
{
    // 创建管道
    int pipefd[2] = {0};
    int n = pipe(pipefd);
    // 子进程继承
    pid_t id = fork();
    if (id == 0)
    {
        // 子进程写端
        close(pipefd[0]);
        std::string message = "我是子进程，我正在给你发消息";
        int count = 0;
        char send_buffer[1024];
        while (true)
        {
            if (count == 5)
                break;
            // 3.2构建一个变化的字符串
            snprintf(send_buffer, sizeof(send_buffer), "%s[%d]:%d", message.c_str(), getpid(), count++);
            // 3.3写入
            write(pipefd[1], send_buffer, strlen(send_buffer));
            sleep(1);
        }
        close(pipefd[1]);
        exit(0);
    }
    // 父进程读端
    close(pipefd[1]);
    char buffer[1024];
    for(int i=0;i<3;i++)
    {
        ssize_t s = read(pipefd[0], buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout << "我是父进程:" << getpid() << "#" << buffer << std::endl;
        }
    }
    close(pipefd[0]);
    int status = 0;
    pid_t res = waitpid(id, &status, 0);
    assert(res > 0);
    (void)res;
    printf("接受到的信号为:%d\n", status & 0x7f);
    return 0;
}