0


Linux——进程间通信1

进程间通信目的

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

进程间通信不是目的,是手段。

技术背景

1.进程是具有独立性的,虚拟地址空间+页表保证进程允许的独立性(进程内核数据结构+进程的代码和数据)

2.通信成本会比较高

进程间通信的本质理解

1.进程间通信的前提,首先需要让不同的进程看到同一块“内存”(特定的结构组织的)

2.这个所谓的“内存”不属于任何一个进程,强调的是共享

进程间通信标准

1.Linux原生能提供——管道(匿名,命名)

2.SystemV——多进程——单机通信

SystemV有共享内存,消息队列,信号量

3.posix——多线程——网络通信

这些标准在使用者看来,都是接口上具有一定的规律。

管道

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

只要是管道就一定有出口和入口,但是出入口数量有n种可能,单向传输内容,管道是用来传资源的。计算机的设计者,设计了一种单向通信模式——管道。

管道通信背后是进程之间通过管道进行通信

每个进程都有一个自己的文件描述符表,进程内部有files*指针,指向自己的文件描述符表,文件描述符表都有自己的数组下标,0,1,2是标准输入,标准输出,标准错误流,linux下一切皆文件,没个文件都有自己的struct_file结构,struct_file不仅包含inode属性,也包含文件对应的内核缓冲区,这个缓冲区在内核中对应的结构叫address_space

  1. 我们以读和写的方式打开同一个文件,给父进程返回的时候会返回俩个文件描述符

2.fork()创建子进程

由于进程具有独立性,子进程会有自己的task_struct和文件描述符表,之后父进程相关的数据会拷贝给子进程,文件描述符表也会拷贝给子进程。

这样不同的进程看到同一份资源(内存),这里这是创建了子进程,我们的目的是子进程,不会拷贝文件相关数据结构,只会拷贝进程相关数据结构。

管道的底层原理就是以文件的形式设计

3.双方进程各自关闭自己不需要的文件描述符。

由于管道是单向通信,我们目前规定父进程写入,子进程读取。

这就叫管道 ,管道就是文件,俩个进程通过文件来进行通信

当我们在上面操作的文件中写入了数据,没必要把这些数据刷新到磁盘中,进程间通信要保证纯内存级别的通信,磁盘是外设。

匿名管道

#include <unistd.h>
功能:创建一无名管道
原型
int pipe(int fd[2]);

输出型参数,期望通过调用它,得到被打开的文件fd,创建成功时返回值为0,失败返回值为-1。

谁调用pipe,就让谁以读写方式打开文件,不需要指定文件名,这个文件是纯内存级别的,如struct_file就不在磁盘中。文件属于内核,一个进程把文件给操作系统,然后另一个进程通过操作系统去读取。
参数
fd:文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0,失败返回错误代码

用代码进行测试

进行调试

如果要不想调试

在-DDEBUG前面加#

此时结果不能打印

我们接下来要实现让父进程写入,子进程读取。

创建子进程,并进行读写通道的建立

read的返回值类型是ssize_t这是long int

snprintf,把特定的字符串内容显示到字符串中

管道实现进程间通信

#include<iostream>
#include<cstdio>
#include<cstring>
#include<unistd.h>
#include<assert.h>
#include<string>
#include<sys/types.h>
#include<sys/wait.h>
using namespace std;
int main()
{
    int pipefd[2]={0};//默认设置为0
    int n=pipe(pipefd);//完成了管道的创建,默认以读写方式打开
    //断言在DEBUG模式下有效,release无效
    //如果没有(void)n n就只被定义而未被使用,可能会在 Realse模式下会出现大量的警告,所以我们加了(void)n
assert(n!=-1);
(void)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);//从读端进行读,将内容读取到buffer中,大小为buffer-1
       if(s>0)//读取成功
       {
        buffer[s]=0;//由于是系统层面的读取,没有\0,所以我们在这添加\0
        cout<<"child get a message["<<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));//把缓冲区的内容写入到写端,这里的strlen后面不需要+1
        //因为管道也是文件,不需要给文件描述符对应的文件写入\0,因为没意义
        //3.4 故意sleep
        sleep(1);
     }
     //等待子进程
     pid_t ret=waitpid(id,nullptr,0);
     assert(ret<0);
     (void)ret;
     close(pipefd[1]);//结束之后,关闭写端,子进程不需要写,因为子进程程序中有exit(0),当推出后,文件描述符会被关掉,此时文件不一定被释放。文件是父进程打开的,当父进程结束时,文件会被释放
    return 0;

}

我们在程序里写端缓冲区有一个buffer,读端缓冲区也有一个buffer, 不用全局buffer是因为有写时拷贝的存在,父子进程要确保自己数据的私有性,再怎么定义全局变量,也无法进行通信。

管道的特点

1.管道是用来进行具有“学院”关系的进程进行进程间通信——常用于父子通信

管道是一个文件,显示器也是一个文件,父子同时往显示器写入的时候,如果没有先后顺序俩个同时写入,这种情况是由于缺乏访问控制。

管道文件,在进行读取的时候,子进程会等待父进程,如这里休眠10s,在休眠的这段时间,子进程一直都在等父进程,所以显示器未打印数据,这叫具有访问控制

2.管道具有通过让进程间协同,提供了访问控制

不控制父进程的写入速度,让子子进程20s后再读

程序一执行,管道就被写满

之后子进程进行读取,一次性把管道里的内容读取完

子进程读取完之后,父进程又开始写,直到写满

3.管道提供的时面向流式的服务——面向字节流一般需要定制协议

4.管道是基于文件的,文件的生命周期时随进程的,管道的生命周期是随进程的(如果父子进程在使用管道通信,通信双方退出,管道会被自动释放)

如果读的时候,写入的一方的fd没有关闭,如果有数据就读,没有数据就等,如果写入的一方fd关闭,读取的一方,read会返回0,表示读到了文件的结尾

写了10次,关闭写端

写入端关闭,子进程 退出

5.管道是单向通信的,就是半双工通信的一种特殊情况(要么一者在接收,要么一者在发送)。 全双工(俩人吵架,俩人同时在说,同时在听)。

a.写快,读慢,写满就不能再写了

b.写慢,读快,管道没有数据的时候,就必须等待

c.写关,读到了0(读到文件结尾,即把所有文件读取完),表示读到了文件结尾

d.读关,写继续写,OS终止写进程

当要写入的数据量不大于PIPE_BUF时,linux将保证写入的原子性(只有做和不做俩种选择)。
当要写入的数据量大于PIPE_BUF时,linux将不再保证写入的原子性。

进程池

每个子进程和父进程形成一个管道,0是fd为0,1是fd为1,当用户要父进程完成任务时,父进程可指派子进程进行完成,可随机选子进程或按照某种特定顺序让子进程执行。

我们在这里让父进程每次写4字节,子进程读四字节

ProcessPool.cc

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include "Task.hpp"

#define PROCESS_NUM 5//进程个数
using namespace std;
int waitCommand(int waitFd,bool &quit)
{
    //uint32_t是4个字节
    uint32_t command=0;
    ssize_t s=read(waitFd,&command,sizeof(command));//从waitFd里读取内容到command,大小为4个字节
   if(s==0)//此时把文件描述符关了
   {
    quit=true;
    return -1;
   }
    assert(s==sizeof(uint32_t));
    return command;//返回读到的命令
}
 void sendAndWakeup(pid_t who, int fd, uint32_t command)
{
    //给who进程通过fd发送command命令
    write(fd, &command, sizeof(command));
    cout << "main process: call process " << who << " execute " << desc[command] << " through " << fd << endl;
}
int main()
{
       load();
    vector<pair<pid_t,int>> slots;//pair的first是pid,second是进程相关信息pipefd
    //slots是一个表,表里存的是子进程的id和pipefd,父进程可以通过该表选择让哪个子进程执行任务
    //创建多个进程
    for(int i=0;i<PROCESS_NUM;++i)
    {
        int pipefd[2]={0};
        //创建管道
        int n=pipe(pipefd);
        assert(n==0);
        pid_t id=fork();
        (void)n;
        assert(id!=-1);
        //子进程让他进行读取
        if(id==0)
        {
            //子进程
            //关闭子进程写端
            close(pipefd[1]);
            while(true)
            {
                bool quit=false;//一开始先不退出,后面要等待命令
                int command=waitCommand(pipefd[0],quit);//子进程等命令,在读取文件描述符那里等命令,如果对方不发命令,我们就阻塞
              if(quit)
              break;
               //执行对应的命令
               if(command>=0&&command<handlerSize())//如果范围之类
               {
                callbacks[command]();//直接调用对应的方法
               }
               else
               {
                cout<<"非法command"<<command<<endl;
               }
            }
            exit(1);
        }
        //父进程
        close(pipefd[0]);
        slots.push_back(pair<pid_t,int>(id,pipefd[1]));//子进程ID,写端描述符
        //把所有的子进程信息,放到vector里,形成一张子进程表
    }
    //整个for循环就是在选择父进程在选择子进程,并且准备给子进程发指令
    //父进程派发任务,用单机版的负载均衡(防止出现一个子进程做多个任务,均衡一下子进程工作量)
    //我们用随机数派发
    srand((unsigned long)time(nullptr)^getpid()^2323232323L);//让数据源更随机
    while(true)
    {
         cout<<"########################################"<<endl;
         cout<<"#  1.show functions   2.send command   #"<<endl;
         cout<<"########################################"<<endl;
         cout<<"Please Select";
         int select;
         int command;//命令
         cin>>select;
         if(select==1)//显示可以被执行的任务
         {
            showHandler();
         }
         else if(select==2)//发送命令
         {
            //选择任务
            cout<<"Enter Your Command";
            cin>>command;//输入命令
            //选择进程
            int choice=rand()%slots.size();
          
            //布置任务,把任务给指定的进程
              sendAndWakeup(slots[choice].first,slots[choice].second,command);//发送命令并且唤醒子进程
         }
         else
         {}
    }
    //关闭fd,结束所有进程
    for(const auto slot:slots)
    {
        close(slot.second);
    }
    //回收所有的子进程信息
    for(const auto slot:slots)
    {
        waitpid(slot.first,nullptr,0);
    }
     return 0;
}

Task.hpp

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <unistd.h>
#include <functional>

typedef std::function<void()> func;//定义一个函数类型,返回值类型void,参数()

std::vector<func> callbacks;//回调
std::unordered_map<int, std::string> desc;

void readMySQL()
{
    std::cout << "sub process[" << getpid() << " ] 执行访问数据库的任务\n" << std::endl;
}

void execuleUrl()
{
    std::cout << "sub process[" << getpid() << " ] 执行url解析\n" << std::endl;
}

void cal()
{
    std::cout << "sub process[" << getpid() << " ] 执行加密任务\n" << std::endl;
}

void save()
{
    std::cout << "sub process[" << getpid() << " ] 执行数据持久化任务\n" << std::endl;
}

void load()
{
    desc.insert({callbacks.size(), "readMySQL: 读取数据库"});//相当于构建键值对,0号命令对应readmysql
    callbacks.push_back(readMySQL);//下标为0,插入ReadMysql

    desc.insert({callbacks.size(), "execuleUrl: 进行url解析"});
    callbacks.push_back(execuleUrl);

    desc.insert({callbacks.size(), "cal: 进行加密计算"});
    callbacks.push_back(cal);

    desc.insert({callbacks.size(), "save: 进行数据的文件保存"});
    callbacks.push_back(save);
}

void showHandler()//显示当前所有的方法
{
    for(const auto &iter : desc )
    {
        std::cout << iter.first << "\t" << iter.second << std::endl;
    }
}

int handlerSize()//共有多少任务的处理方法
{
    return callbacks.size();
}

习题

1.以下描述正确的有:B

A.进程之间可以直接通过地址访问进行相互通信

B.进程之间不可以直接通过地址访问进行相互通信

C.所有的进程间通信都是通过内核中的缓冲区实现的

D.以上都是错误的

A错误: 进程之间具有独立性,拥有自己的虚拟地址空间,因此无法通过各自的虚拟地址进行通信(A的地址经过B的页表映射不一定映射在什么位置)

B正确

C错误: 除了内核中的缓冲区之外还有文件以及网络通信的方式可以实现

2.以下选项属于进程间通信的是(A,B,D)[多选]

A.管道

B.套接字

C.内存

D.消息队列

典型进程间通信方式:管道,共享内存,消息队列,信号量。 除此之外还有网络通信,以及文件等多种方式

C选项,这里的内存太过宽泛,并没有特指某种技术,错误。

3.下列关于管道(Pipe)通信的叙述中,正确的是(C)

A.一个管道可以实现双向数据传输

B.管道的容量仅受磁盘容量大小限制

C.进程对管道进行读操作和写操作都可能被阻塞

D.一个管道只能有一个读进程或一个写进程对其操作

A错误 管道是半双工通信,是可以选择方向的单向通信

B错误 管道的本质是内核中的缓冲区,通过内核缓冲区实现通信,命名管道的文件虽然可见于文件系统,但是只是标识符,并非通信介质

C正确 管道自带同步(没有数据读阻塞,缓冲区写满写阻塞)与互斥

D错误 多个进程只要能够访问同一管道就可以实现通信,不限于读写个数

4.以下关于管道的描述中,正确的是 [多选]B,D

A错误,匿名管道只能用于具有亲缘关系的进程间通信,命名管道可以用于同一主机上的任意进程间通信

B正确

C错误,匿名管道需要在创建子进程之前创建,因为只有这样才能复制到管道的操作句柄,与具有亲缘关系的进程实现访问同一个管道通信

D正确

5.以下关于管道的描述中错误的是 [多选]B,C

A.可以通过int pipe(int pipefd[2])接口创建匿名管道,其中pipefd[0]用于从管道中读取数据

B.可以通过int pipe(int pipefd[2])接口创建匿名管道,其中pipefd[0]用于向管道中写入数据

C.若在所有进程中将管道的写端关闭,则从管道中读取数据时会返回-1;

D.管道的本质是内核中的一块缓冲区;

  • 管道本质是内核中的一块缓冲区,多个进程通过访问同一块缓冲区实现通信。
  • 使用int pipe(int pipefd[2])接口创建匿名管道,pipefd[0]用于从管道读取数据,pipefd[1]用于向管道写入数据。
  • 管道特性:半双工通信,自带同步与互斥,生命周期随进程,提供字节流传输服务。
  • 在同步的提现中,若管道所有写段关闭,则从管道中读取完所有数据后,继续read会返回0,不再阻塞;若所有读端关闭,则继续write写入会触发异常导致进程退出

根据以上管道理解分析:A正确,B错误,C错误,D正确

因为题目为选择错误选项,因此选择B和C选项

标签: linux 网络 运维

本文转载自: https://blog.csdn.net/weixin_49449676/article/details/128296723
版权归原作者 头发没有代码多 所有, 如有侵权,请联系我们删除。

“Linux——进程间通信1”的评论:

还没有评论