[Linux]：进程间通信(上)

最新推荐文章于 2024-09-16 11:19:03 发布

Betty’s Sweet

最新推荐文章于 2024-09-16 11:19:03 发布

阅读量860

点赞数 28

分类专栏： Linux 文章标签： linux 进程间通信管道匿名管道命名管道

本文链接：https://blog.csdn.net/Bettysweetyaaa/article/details/142290085

版权

Linux 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：Linux学习
贝蒂的主页：Betty’s blog

1. 进程间通信介绍

1.1 进程间通信的概念

进程间通信简称IPC（Interprocess communication），进程间通信就是在不同进程之间传播或交换信息。

因为进程之间具有独立性，所以一个进程是无法与另一个进程进行交流的，但是有些情况下我们一个进程必须要

进程接受一个进程的信息，所以操作系统为其提供了特定的方式。

1.1 进程间通信的目的

数据传输：一个进程要把自己的数据交给另一个进程,让其继续进行处理。
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常,并能够及时知道它的状态改变。

1.1 进程间通信的本质

在操作系统中，运行的进程具有独立性，主要体现在数据层面，代码逻辑则有私有和公有情况(父子进程)。这使得进程间通信颇具难度。为实现通信，进程需借助第三方资源，即操作系统提供的一段内存区域。

所以本质上，进程间通信就是让不同进程看到同一份资源，如内存或文件内核缓冲等。因资源可由操作系统不同模块提供，所以就产生了多种进程间通信方式。

2. 匿名管道

2.1 管道的概念

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

比如我说我们可以通过指令who | wc -l统计当前使用服务器的用户个数，其中指令who为查看当前服务器的登录用户，指令wc -l为统计当前行数，它们运行起来会成为两个进程。但是我们通过管道|将其链接起来，让指令wc -l读取who指令打印出的数据。

2.2 匿名管道

在进程间通信中，匿名管道是一种单向通信机制。它通常用于具有“血缘关系”的进程之间，并且匿名管道只能在本地机器上使用，不能用于网络通信。

其原理就是，创建一个子进程，让父子进程都指向同一个文件，最后我们就可以让父进程向文件写入/读取数据，子进程向文件读取/写入数据。

那么现在我们肯定有一个疑问，那就是创建子进程时，文件描述符数组fd_array会拷贝一份，但是指向的文件为什么不需要拷贝呢？

因为这个数组是为了让该进程能知晓已经打开的文件的个数，所以文件描述符数组fd_array是属于进程的，既然属于进程，那子进程也需要拷贝一份，因为进程具有独立性。而这个文件是由我们操作系统所管理的，并不属于我们进程，所以子进程在拷贝时并不会再创建一份文件。

并且值得注意的是：

因为父子进程共用的文件资源是由操作系统来维护的，所以当父子进程对该文件进行写入操作时，该文件缓冲区当中的数据并不会发生写时拷贝。比如说我们父子进程打印信息是在同一个屏幕打印的，而不是分别打印在两个屏幕上。
虽然管道使用的是文件，但操作系统一定不会把进程进行通信的数据刷新到磁盘当中，因为这样做有IO参与会降低效率。也就是说，这种文件是一批不会把数据写到磁盘当中的文件，换句话说，磁盘文件和内存文件不一定是一一对应的，有些文件只会在内存当中存在，而不会在磁盘当中存在。

2.3 pipe函数

并且Linux系统中也为我们提供了创建匿名管道的函数——pipe函数，其使用方式如下：

函数原型：int pipe(int pipefd[2]);
返回值：创建成功返回0，否则返回-1。
参数：pipefd[2]是一个输出型参数，其中pipefd[0]代表的是管道读端的文件描述符，pipefd[1]代表的是管道写端的文件描述符。

然后我们就可以使用我们代码来实现我们的进程间通信，其中我们让父进程写入数据，子进程读取数据。

首先第一步父进程创建出一个管道。

第二步父进程创建子进程。

最后一步关闭对应读写端，实现单向通信。

代码实现如下：

#include<cstdio>
#include<cstdlib>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<iostream>
#include<cstring>
#include<string>
using namespace std;
#define N 2
#define NUM 1024
void writer(int wfd)
{
    string str="hello child, i am father";
    pid_t id=getpid();
    int num=0;
    char buffer[NUM];
    while(true)
    {
        buffer[0] = 0; // 字符串清空，只是为了提醒阅读代码的人，我把这个数组当做字符串了
        snprintf(buffer,sizeof(buffer),"%s-%d-%d",str.c_str(),id,num);
        write(wfd,buffer,strlen(buffer));
        sleep(1);
        num++;
    }

}
void reader(int rfd)
{
    char buffer[NUM];
    while(true)
    {
        ssize_t n=read(rfd,buffer,sizeof(buffer)-1);
        if(n>0)
        {
            buffer[n]=0;
        }
        cout<<"child ("<<getpid()<<") get a message："<<buffer<<endl;
    }
}
int main()
{
    int pipefd[2]={0};
    if(pipe(pipefd) < 0)
    {
        perror("pipe:");
        return 1;
    }
    pid_t id = fork();
    if(id==0)
    {
        //child->read
        close(pipefd[1]);//关闭写端
        reader(pipefd[0]);
        close(pipefd[0]);
    }
    else if(id>0)
    {
        //father->write
        close(pipefd[0]);
        writer(pipefd[1]);
        //进程等待
        pid_t ret=waitpid(id,nullptr,0);
        if(ret<0)
        {
            perror("waitpid:");
            return 1;
        }
        close(pipefd[1]);
    }
    else
    {
        //fork error
        perror("fork:");
        return 1;
    }
    return 0;
}

3. 命名管道

3.1 命名管道

匿名管道只能用于具有"亲缘关系"的进程间通信，所以匿名管道就具有局限性，如果我们想让两个毫不相关的进程间进行通信，就需要使用我们的命名管道。

命名管道与匿名管道都是只存在于内存中的文件，并不会向磁盘刷新，唯一不同的是匿名管道是通过父子进程看到同一份资源，而命名管道是通过路径与文件名的方式找到同一份文件资源，因为我们知道路径具有唯一性。

3.2 mkfifo函数

首先我们可以在命令行通过指令mkfifo 管道名创建一个命名管道，并且我们可以直接通过其进行通信。

然后我们可以在程序中mkfifo函数进行管道创建：

函数原型：int mkfifo(const char *pathname, mode_t mode);
返回值：创建成功返回0，否则返回-1。
参数：mkfifo函数的第一个参数是pathname，表示要创建的命名管道文件。若pathname以路径的方式给出，则将命名管道文件创建在pathname路径下。若pathname以文件名的方式给出，则将命名管道文件默认创建在当前路径下。mkfifo函数的第二个参数是mode，表示创建命名管道文件的默认权限，其守默认掩码umask的约束。

比如说我们可以通过该接口实现客户端client与服务端server间的通信。

首先是需要包含的头文件，以及为了方便管理管道，我们可以将管道文件名定义为宏。

//comment.h
#pragma once
#include<stdio.h>
#include<sys/stat.h>
#include<sys/stat.h> 
#include<sys/types.h> 
#include<fcntl.h> 
#include<unistd.h> 
#define MY_FIFO "./fifo"  //管道的创建路径

以下分别为server.c与client.c的实现：

//server.c
#include"comment.h"
int main()
{
    umask(0);//将文件默认掩码设置为0
    if(mkfifo(MY_FIFO,0666)<0)  //创建管道
    {
        perror("mkfifo:");
        return 1;
    }
    int fd = open(MY_FIFO,O_RDONLY);//以读方式打开命名管道文件
    if(fd<0)
    {
        perror("open");
        return 2;
    }
    //处理业务逻辑,进行相应的读写
    while(true)
    {
        char buffer[64] = {0};
        ssize_t s =  read(fd,buffer,sizeof(buffer)-1);
        if(s > 0)
        {
            //读取成功
            buffer[s] = 0;//字符串末尾置\0
            printf("client send: %s\n",buffer);
        }
        else if(s == 0)
        {
            //写端关闭，读取数据个数为0，
            printf("client close\n");
            break;
        }
        else
        {
            //读取错误
            perror("read:");
            break;
        }
    }
    close(fd);
    return 0;
}

#include"comment.h"
#include<string.h>   
int main()
{
    int fd = open(MY_FIFO,O_WRONLY);//以写方式打开命名管道文件
    if(fd<0)
    {
        perror("open:");
        return 1;
    }
    
    //处理业务逻辑
    while(1)
    {
        char buffer[64] = {0};
        //1.先从键盘读取内容
        printf("enter Message: ");
        fflush(stdout);//刷新缓冲区
        //从键盘读数据
        ssize_t s = read(0,buffer,sizeof(buffer)-1);
        if(s > 0)
        {
            buffer[s -1]= 0;//提前置\0，把\n覆盖掉
            //向管道中写入数据
            write(fd,buffer,strlen(buffer));
        }
    }
    close(fd);
    return 0;
}

我们通过管道通信还可以实现很多功能，比如我们可以与进程替换相结合实现一个进程对另一个进程的控制等，当然我们这里就不在实现，感兴趣可以自己实现。

最后我们学习完管道相关知识之后，可能会提出以下疑惑：

命令行管道"|"究竟是匿名管道还是命名管道呢？

我们其实可以通过命令行来直接验证一下：

通过观察我们发现，三个sleep进程的PPID都是相同的，即这三个子进程都是"兄弟进程"，所以我们命令行管道是匿名管道。

4. 管道的特点

管道具有以下几个特点：

自带同步与互斥机制

管道在同一时刻只允许一个进程进行写入或读取操作，属于临界资源。为避免多个进程同时操作管道导致同时读写、交叉读写及数据不一致等问题，内核会对管道操作进行同步与互斥。

互斥保证一个公共资源同一时刻只能被一个进程使用，对于管道场景即两个进程不能同时操作，需相互等待。
同步则要求两个或以上进程按预定先后次序运行，在管道场景中不仅不能同时操作，还需按特定次序操作。

生命周期随进程

管道本质上通过文件进行通信，依赖于文件系统。当所有打开该文件的进程都退出后，对应的管道文件也会被释放，所以管道的存在与使用进程紧密相关，其生命周期随进程。

提供流式服务

进程 A 写入管道的数据，进程 B 每次从管道读取的数据量是任意的，没有明确的数据分割，不分报文段，这种服务方式被称为流式服务。与数据报服务不同，数据报服务的数据有明确分割，按报文段进行处理。

半双工通信

单工通信(Simplex Communication)：单工模式的数据传输是单向的。通信双方中，一方固定为发送端，另一方固定为接收端。
半双工通信(Half Duplex)：半双工数据传输指数据可以在一个信号载体的两个方向上传输，但是不能同时传输。
全双工通信(Full Duplex)：全双工通信允许数据在两个方向上同时传输，它的能力相当于两个单工通信方式的结合。全双工可以同时(瞬时)进行信号的双向传输。

管道是面向字节流的，其大小最大为65536字节，即64KB。

5. 管道的特殊情况

在使用管道通信时，可能会出现以下四种特殊情况：

情况一：若写端进程不进行写入操作，而读端进程一直尝试读取。此时由于管道中没有数据可供读取，读端进程会被挂起，处于等待状态。只有当管道中有数据时，读端进程才会被唤醒，继续进行读取操作。
情况二：当读端进程不进行读取，而写端进程持续写入时，一旦管道被写满，写端进程就会被挂起。只有在管道中的数据被读端进程读取后，写端进程才会被唤醒，继续进行写入操作。
情况三：当写端进程将数据写完后关闭写端，读端进程在将管道中的数据全部读完后，此时read返回值为0，我们可以继续执行该进程之后的代码逻辑。
情况四：若读端进程关闭读端，而写端进程仍在持续向管道写入数据，此时操作系统会将写端进程杀掉。

前三种情况我们都可以很好理解，我们最后验证一下情况四，既然其会被操作系统杀死，我们就可以通过进程等待获取退出信息来验证：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	int fd[2] = { 0 };
	if (pipe(fd) < 0)
	{ 
		perror("pipe");
		return 1;
	}
	pid_t id = fork(); //创建子进程
	if (id == 0)
	{
		//child
		close(fd[0]); 
		//子进程向管道写入数据
		const char* msg = "hello father, I am child";
		int count = 5;
		while (count--)
		{
			write(fd[1], msg, strlen(msg));
			sleep(1);
		}
		close(fd[1]); //子进程写入完毕，关闭文件
		exit(0);
	}
	//father
	close(fd[1]); //父进程关闭写端
	close(fd[0]); //父进程直接关闭读端
	int status = 0;
	waitpid(id, &status, 0);
	printf("child get signal:%d\n", status & 0x7F); //打印子进程收到的信号
	return 0;
}