进程间通信-匿名管道与命名管道

1.进程间通信
进程间通信是两个或者多个进程之间进行通信，行为如下：
数据传输：一个进程需要将它的数据发送给另一个进程。
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
2.匿名管道
匿名管道的读写特征:
①.如果读取慢,写入快,write调用阻塞,直到有进程读走数据
②.如果写入慢,读取快,read调用阻塞,直到有进程写入数据
③.管道写端对应的文件描述符被关闭，则read返回0。
④.管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE，让write进程退出。

a. 管道的4种情况
①. 正常情况，如果管道没有数据了，读端必须等待，直到有数据为止(写端写入数据了)
②. 正常情况，如果管道被写满了，写端必须等待，直到有空间为止(读端读走数据)
③. 写端关闭，读端一直读取, 读端会读到read返回值为0， 表示读到文件结尾
④. 读端关闭，写端一直写入，OS会直接杀掉写端进程，通过想目标进程发送SIGPIPE(13)信号，终止目标进程
b. 管道的5种特性
①. 匿名管道,可以允许具有血缘关系的进程之间进行进程间通信，常用与父子,仅限于此
②. 匿名管道，默认给读写端要提供同步机制
③. 面向字节流的
④. 管道的生命周期是随进程的
⑤. 管道是单向通信的，半双工通信的一种特殊情况

#include <iostream>
#include <cassert>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#define MAX 1024
using namespace std;

int main()
{
    // 第1步，建立管道
    int pipefd[2] = {0};
    int n = pipe(pipefd);
    assert(n == 0);
    (void)n; /
    cout << "pipefd[0]: " << pipefd[0] << ", pipefd[1]: " << pipefd[1] << endl;
    // 第2步，创建子进程
    pid_t id = fork();
    if (id < 0)
    {
        perror("fork");
        return 1;
    }
    // 子写，父读
    // 第3步，父子关闭不需要的fd，形成单向通信的管道
    if (id == 0)
    {
        close(pipefd[0]);
        // w - 只向管道写入，没有打印
        int cnt = 0;
        while(true)
        {
            char message[MAX];
            snprintf(message, sizeof(message), "hello father, I am child, pid: %d, cnt: %d", getpid(), cnt);
            cnt++;
            write(pipefd[1], message, strlen(message));
            sleep(1);
        }
        cout << "child close w piont" << endl;
        exit(0);
    }
    // 父进程
    close(pipefd[1]);
    // r
    char buffer[MAX];
    while(true)
    {
        // sleep(2000);
        ssize_t n = read(pipefd[0], buffer, sizeof(buffer)-1);
        if(n > 0)
        {
            buffer[n] = 0; // '\0', 当做字符串
            cout << getpid() << ", " << "child say: " << buffer << " to me!" << endl;
        }
        else if(n == 0)
        {
            cout << "child quit, me too !" << endl;
            break;
        }
        cout << "father return val(n): " << n << endl;
        sleep(1);

        break;
    }
    cout << "read point close"<< endl;
    close(pipefd[0]);
    sleep(5);
    int status = 0;
    pid_t rid = waitpid(id, &status, 0);
    if (rid == id)
    {
        cout << "wait success, child exit sig: " << (status&0x7F) << endl;
    }
    return 0;
}

关于代码其中的函数
①.int pipe(int fd[2])
参数:
fd:文件描述符数组,
int pipefd[2]是一个输出型参数，是一个数组，该数组只有两个元素，下标分别为0和1。
下标为0的元素表示的是管道读端的文件描述符fd。
下标为1的元素表示的是管道写端的文件描述符fd。
返回值:成功返回0,失败返回错误代码

创建管道后返回的两个fd值，果然是3和4，因为0,1,2分别被stdin，stdout，stderr占用。
②.snprintf函数
int snprintf(char *str, size_t size, const char *format, …);
str：指向用于存储格式化后的字符串的字符数组的指针。
size：输出字符数组 str 的最大长度（包括终止空字符 \0），用于防止缓冲区溢出。
format：格式化字符串，包含了要插入到输出字符数组中的文本和格式说明符。
…：可变参数列表，用于提供格式化字符串中各个格式说明符所对应的值。
snprintf 函数根据指定的格式字符串 format，将格式化后的字符串写入到 str 指向的字符数组中，直到遇到空字符 \0 或达到最大长度 size - 1（最后一个字符保留给空字符 \0）。如果格式化后的字符串长度超过了指定的最大长度 size - 1，则会截断超出部分，并返回实际需要写入的字符数（不包括终止空字符 \0）；否则，返回格式化后的字符串的长度（不包括终止空字符 \0）。
③.write函数 read函数
write 函数：
函数原型：ssize_t write(int fd, const void *buf, size_t count);
参数说明：
fd：文件描述符，表示要写入数据的文件或者其他类型的 I/O 设备。
buf：指向要写入数据的缓冲区的指针。
count：要写入的字节数。
返回值：如果成功，返回写入的字节数，如果出错，则返回 -1，并设置全局变量 errno 来指示错误的类型。
函数功能：write 函数将 buf 指向的数据写入到文件描述符 fd 指向的文件或者其他类型的 I/O 设备中。

read 函数：
函数原型：ssize_t read(int fd, void *buf, size_t count);
参数说明：
fd：文件描述符，表示要读取数据的文件或者其他类型的 I/O 设备。
buf：指向存放读取数据的缓冲区的指针。
count：要读取的最大字节数。
返回值：如果成功，返回读取的字节数，如果已到达文件末尾，则返回 0，如果出错，则返回 -1，并设置全局变量 errno 来指示错误的类型。
函数功能：read 函数从文件描述符 fd 指向的文件或者其他类型的 I/O 设备中读取数据，并将数据存储到 buf 指向的缓冲区中
④.waitpid函数

3.命名管道
可以在shell中通过命令的方式创建管道文件，两个进程直接去使用它。也可以像文件一样，在进程中创建管道文件，此时就需要用到系统调用。
int mkfifo(const char *pathname, mode_t mode);
pathname：要创建的命名管道的路径名。可以是相对路径或绝对路径。
mode：创建的文件权限，通常使用八进制数表示，如 0666。
返回值：
若成功，返回 0；
若失败，返回 -1，并设置 errno 来指示错误类型。
如果成功，mkfifo 函数将创建一个新的命名管道文件，并根据指定的权限设置其访问权限。如果文件已存在，则会报错并返回 -1。

//servePipe.c
#define ERR_EXIT(m) \
	do{\
	    perror(m);\
	    exit(EXIT_FAILURE);\
}while(0);
//这个函数可以显示错误 

int main(){
	umask(0);
	if(mkfifo("mypipe",0664)<0){
		ERR_EXIT("mkfifo");
	}  //如果失败返回-1 
	int rfd=open("mypipe",O_RDONLY);
	if(rfd<0){
		ERR_EXIT("open");
	}
	char buf[1024];
	while(1){
	  buf[0]=0;
	  printf("please wait..\n");
	  ssize_t s=read(rfd,buf,sizeof(buf)-1);
	  if(s>0){
	      buf[s-1]=0;
		  printf("client say# %s\n",buf);	
	  }	
	  //read
	  else if(s==0){
	  	printf("client quit,exit now!\n");
	  	exit(EXIT_SUCCESS);
	  }
	  //read函数返回0则表示已经读到文件结尾 
	  else{
	  ERR_EXIT("read"); 
	} 
}

//clientPipe.c
int main(){
	int wfd=open("mypipe",O_WRONLY);
	if(wfd<0){
		ERR_EXIT("open");
	}
	char buf[1024];
	while(1){
	  buf[0]=0;
	  printf("Please Enter# ");
	  fflush(stdout);
	  ssize_t s=read(0,buf,sizeof(buf)-1);
	  if(s>0){
	  	 buf[s]=0;
	  	 write(wfd,buf,strlen(buf));
	  }	
	  else if(s<=0){
	  	 ERR_EXIT("read");
	  }
	}
	close(wfd);
	
	return 0;
}

命名管道的读写特征:
①.当读端要打开管道，而写端没有打开时，会在读端的open处阻塞。
②.当写端要打开管道，而读端没有打开时，会在写端的open处阻塞。
除了读写时的特征，命名管道本身也有特征：命名管道的生命周期随内核。
我们可以看到，管道文件是可以直接在磁盘上存在的，和进程无关，这一点和命名管道不一样，其他的特征都一样。

匿名管道和命名管道的区别：
匿名管道由pipe函数创建并打开。
命名管道由mkfifo函数创建，打开用open，删除用unlink函数。
FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一但这些工作完成之后，它们具有相同的语义