进程通信

进程之间可能会存在特定的协同工作场景。

一个进程要把自己的数据交付给另一个进程，让其进行出来处理。而一个进程把自己的数据交付给另一个进程的动作，就叫做进程通信。

前提

进程是具有独立性的，交互数据的成本一定很高（一个进程看不到另一个进程的资源）。因此要完成进程间通信，不能只在应用层解决，需要操作系统干预进行解决。即操作系统要设计通信方式。

进程要通信，因其独立性，必须得先看到一份公共的资源（里面有相关数据等）。这里的公共的资源是一段属于操作系统的内存。因此，进程间通信的前提本质，其实是由OS参与，提供一份所有通信进程能看到的公共资源。

这段操作系统所提供的内存，可能以文件方式提供，也可能以队列的方式，也可能提供的就是原始的内存块……这也就是通信方式有很多种的原因。

总的来说，进程通信要解决的最根本的问题就是，如何让两个不同的进程看到一份公共资源。

进程间通信的目的

进程间通信发展

进程间通信分类

管道

System V IPC

POSIX IPC

管道

认识管道

匿名管道

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

父子进程是两个独立的进程，因此父子通信也属于进程通信的一种。匿名管道就是基于父子。

匿名管道的本质就是：通过子进程继承父进程资源的特性，达到一个让不同的进程看到同一份资源。

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

分别以读方式和写方式打开文件

管道是一个只能单向通信的通信信道，若需双向通信，则需建立两个管道。

//从键盘读取数据，写入管道，读取管道，写到屏幕
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
int main(){
  int pipefd[2] = {0};
  if(pipe(pipefd) != 0){
    perror("pipe error");
    return 1;
  }
  //pipefd[0] pipefd[1]
  //0(嘴)：读取端  1(笔)：写入端
  printf("pipefd[0]: %d\n", pipefd[0]);
  printf("pipefd[1]: %d\n", pipefd[1]);

  //我们想让父进程进行读取，子进程写入
  if(fork() == 0){
    //子进程
    close(pipefd[0]); //子进程写入，故关闭读取端
    
    const char *msg = "hahaha!";
    while(1){
      //pipe里面只要有缓冲区，就一直写入
      write(pipefd[1], msg, strlen(msg)); //strlen(msg)+1 ?? 不需要 \n不被写入
      //sleep(1);
    }
    exit(0);
  }
  //父进程
  close(pipefd[1]); //父进程读取，故关闭写入端
  while(1){
    //没有让父进程sleep->子进程写得慢，父进程读得快
    //让父进程sleep，只要有数据，就可以一直读取
    sleep(1);
    char buffer[64] = {0};
    ssize_t s = read(pipefd[0], buffer, sizeof(buffer)-1);//如果read的返回值是0，意味子进程关闭文件描述符
    if(s == 0){
      printf("child quit...\n");
      break;
    }
    else if(s > 0){
      buffer[s] = 0;
      printf("child say# %s\n", buffer);
    }else{
      printf("read error...\n");
      break;
      }
  }
  return 0;
}

//pipefd[2]:是一个输出性参数！我们想通过这个参数读取到打开的两个fd
//int pipe(int pipefd[2]); 成功返回0，失败返回-1

管道读取规则

若只让子进程写入，父进程不读只休眠

若是让父进程每休眠10秒后读一个字符，通过实践可以发现，子进程不会继续写入，每休眠10秒后读64字符，子进程依旧不会继续写入……而当每休眠10秒后读的字符增加到1024个字符时（足够多），子进程会继续写入。

这就是管道自带的同步机制。

读写规则

当没有数据可读时

当管道满时

其他

管道特点

为了解决匿名管道只能父子通信，引入了命名管道。

命名管道

通过man手册查看命名管道的定义

命名管道的命令行操作

创建命名管道

//server.h
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>

#define MY_FIFO "./fifo"
int main(){
  umask(0);
  //创建一个命名管道，如果失败返回1
  if(mkfifo(MY_FIFO, 0666) < 0){
    perror("mkfifo");
    return 1;
  }
  return 0;
}

一旦具有了命名管道，此时，我们只需要让通信双方按照文件操作即可。

comm.h

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#define MY_FIFO "./fifo"

server.c

#include "comm.h"
int main(){
  umask(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(1){
    char buffer[64] = {0};
    ssize_t s = read(fd, buffer, sizeof(buffer)-1);
    if(s > 0){
      //success
      buffer[s] = 0;
      printf("client# %s\n", buffer);
    }
    else if( s == 0){
      //peer close
      printf("client quit...\n");
      break;
    }else{
      //error
      perror("read");
      break;
    }
  }
  close(fd);
  return 0;
}

client.c

#include "comm.h"
int main(){
  //无需再创建fifo，只需获取即可
  int fd = open(MY_FIFO, O_WRONLY);
  if(fd < 0){
    perror("open");
    return 1;
  }
  //业务逻辑
  while(1){
    printf("请输入# ");
      fflush(stdout);
    char buffer[64] = {0};
    //先把数据从标准输入拿到我们的client进程内部
    ssize_t s = read(0, buffer, sizeof(buffer)-1); //使用的系统调用，/n也是输入字符的一部分，故需要s-1
    if(s > 0){
      buffer[s-1] = 0;
      printf("%s\n", buffer);

      //拿到了数据
      write(fd, buffer, strlen(buffer));
    }
  }
  close(fd);
  return 0;
}

运行效果：

server.c

#include "comm.h"
#include <sys/wait.h>
int main(){

  umask(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(1){
    char buffer[64] = {0};
    ssize_t s = read(fd, buffer, sizeof(buffer)-1);
    if(s > 0){
      //success
      buffer[s] = 0;
      if(strcmp(buffer, "show") == 0){

        if(fork() == 0){
          execl("/usr/bin/ls", "ls", "-l", NULL);
          exit(1);
        }
      waitpid(-1, NULL, 0);
      }    
      else if(strcmp(buffer, "run") == 0){
        if(fork() == 0){
          execl("/usr/bin/sl", "sl", NULL);
        } 
        waitpid(-1, NULL, 0);
      }
      else{
        printf("client# %s\n", buffer);
      }
    }
    else if( s == 0){
      //peer close
      printf("client quit...\n");
      break;
    }else{
      //error
      perror("read");
      break;
    }
  }
  close(fd);
  return 0;
}