做购物网站多少钱 知乎,构建一个网站的步骤,网页搜索快捷键ctrl加什么,精品资源共享课网站建设 碧辉腾乐进程通信 初步理解进程通信 所谓进程之间的通信#xff0c;就是两个进程之间的 数据层面的交互。 我们之前说过#xff0c;父子进程之间是有一些数据通信的#xff0c;子进程可以看到一些父进程 允许 子进程访问的数据#xff0c;比如 父进程的 环境变量#xff0c;子…进程通信 初步理解进程通信  所谓进程之间的通信就是两个进程之间的 数据层面的交互。 我们之前说过父子进程之间是有一些数据通信的子进程可以看到一些父进程 允许 子进程访问的数据比如 父进程的  环境变量子进程可以直接继承 但是子进程只能访问数据一旦父进程或者是子进程对这个数据进行了修改那么都会发生写时拷贝。 所以上述只是特殊情况进程和进程之间是具有独立性的一个进程的运行如果是不是 在 运行逻辑上依赖于某一个进程的话那么进程和进程之间是独立运行的。一个进程挂掉是不影响其他进程的 运行的。 所以进程的独立性对于进程运行之间的耦合性有了显著的降低但是对于进程间通信来说就有点麻烦了。 这也不能怪进程的设计上有缺陷我们发现进程的独立性所带来的好处是非常多的而进程的设计理念就是为了实现 不同 代码的 独立执行。 因为有进程独立性的存在导致进程通信的成本增加了。 对于一个进程对另一个进程发送出的数据有很多种如在述举例 基本数据比如 字符串整形数据报文······指令/命令数据可以发送命令性数据实现对另一个进行的控制实现控制另一个进程的比如进程的创建终止等待替换····   协同数据一个进程想用另一个进程去帮助这个进程 去做一些任务当另一个进程不做任务的时候让这个进程等待或者是停止下来等等的这些操作。通知数据子进程 死亡之前要变成僵尸进程等待父进程 回收数据也会说A 进程 可以告诉 B 进程 发生什么事情···· 等等这些。······················ 通过上述对于 进程之间具有独立性的简单描述就可以知道进程之间通信是有成本的 这个成本就体现在他要在不破坏进程之间的独立性的前提之下实现进程之间的数据的交互。 而进程通信的本质就是 --  必须要让不同进程之间看到同一份“资源”。这个资源可以理解为 特定形式的一种内存空间 那么这块 “资源” 由谁去提供呢答案就是操作系统了。 操作系统在内存当中开辟一块新的空间这块空间就是这两个 进程共用的 “资源”。如果进程 A 想给 进程 B 发送数据那么 只需要往这个 由 操作系统新开辟的空间当中写入要传递的数据进程 B 直接去读取就可以了。 但是操作系统为什么要想上述一样做呢 如果是进程 A 想给 进程 B 发送数据 的话进程A 直接共享 在自己的 进程地址空间当中映射的 物理存储位置 不就可以了吗 上述的 进程 直接共享自己空间当中存储的 数据 给 其他进程这种方式是不可行的因为这种方式 破坏了进程之间的独立性。 想想如果进程直接把自己空间当中的数据直接共享出去不就相当于是直接把自己家的地址直接共享了吗 我们想的是其他进程不知道我当前共享数据的进程存储数据的位置不想被人知道在进程自己 “家” 当中存储的数据。 共享数据的进程指向把数据直接放到 每一个 共享的位置处由需要的进程自己接收。 所以一个进程向另一个进程访问数据的操作就转变为了 一个进程向操作系统访问数据的过程了。本质上就是访问 操作系统。 那么操作系统不能直接让进程访问到 其中的内存万一这个进程是病毒木马或者当前用户对进程的操作有误····· 等等这些都是可能会对 操作系统甚至是计算机造成不好的影响的。 所以进程这里进程其实就是代表的是用户了要想访问到操作系统就得使用 操作系统提供的 各种 -- 系统调用接口。 而当前在 系统当中运行的 进程肯定是不止一个的那么进程之间的通信就变得很复杂了在同一时间段内可能有有多个进程都想要通信。 所以操作系统为了满足当前进程之间的需求就要在内存当中开辟很多个大小不一的 空间“资源”供多个进程之间通信的使用。 那么操作系统为了能更好的管理好这些个“资源”就会使用 --- 先描述再组织。这个方法。 也就是把管理一个“资源”所要用到的 各种属性用一个 结构体对象来存储多个“资源”肯定是对应了很多个 结构体对象此时用某种数据结构把这些 结构体对象 链接起来。操作系统只需要管理好这个 数据结构就可以管理好 所有的 结构体对象管理好所有的结构体对象就可以管理好 所有的 “资源”。 一般操作系统会有一个独立的通信模块IPC 通信模块这个模块其实是隶属于 文件系统的。 操作系统 从底层实现到用户层 其实是 由很多人去写的也就是说由很多人来写进程之间的通信这一模块的内容所以就衍生出了很多的版本不同发行的版本之间 标准。 出现了各种的解决方案的话我们需要从中选出  效率高使用方便的一种方案或者是几个方案。所以就要定制标准大家都按照 这个标准来实现那么大家虽然在一些细节上的实现不太一样的但是大体上还是按照一个标准来实现的。 所以进程间通信是有标准的。 我们可以想想每个人都是可以使用不同厂家生产出来的不同硬件设备不同软件设计 的 设备但是尽管有很大的差异每个人都可以使用的不同的设备和不同设备的人进行通信 也就是不同的设备之间尽管有在硬件 和 软件的设计之上有很大不同但是都是可以进行继承之间的通信的。为什么呢 因为不管是哪一个行业总是会有一群“佼佼者” 走在这个行业的最前端他们就可以制定出规则供我们进行适配使用。 如果没有这些标准设备和设备之间就很难进行通信也就没有今天这种互联网局势。 在进程通信当中就有两个标准 system V posix 管道 一个文件是可以被进程所打开的那么一个文件能不能被多个进程打开并访问呢 如果一个文件可以被多个进程打开并访问那么这个文件不就相当于是一个 公共资源 了吗  一个进程从文件当中写数据另一个进程从该文件当中读取数据只要保证往文件当中写数据的 进程 他写完数据马上刷新缓冲区当中的数据到 磁盘上另一个进程就可以访问到这个数据。 但是虽然上述的这种方式是可以实现的但是基于文件的来实现的通信有一个致命的问题 --- “公共资源” 在外设上。 也就是说需要把数据写到外设上那么从把数据写到外设上 -- 到把数据从外设上读取到内存当中用于进程的接收。 在这个过程当中一定会伴随着一个 数据读取的 效率问题。 比如外设当中的存储效率根本比不上 内存当中的存储效率也就是说其实在缓冲区出来之前其实内存是要放慢速度等待 外存写入数据的。······· 所谓 “管道” 呢其实就是一种基于文件的一种通信方式。 它的思想其实和上述所说的文件 作为 “共享资源” 的思想差不多只不过他不把数据刷新到 磁盘上管道通信 只需要建立好 双方的通信信道进程往其中写入数据另一个进程进行读取即可不需要使用到磁盘用内存也是可以的。 什么是管道 管道 是 Unix 中最古老的进程间通信的形式。因为 Linux 本身就是一种 类UNIX 操作系统。所以UNIX 支持 管道Linux 也支持管道。 关于管道的简单定义我们把一个进程 把数据 写到 另一个进程的 数据流 称之为 -- 管道。 而管道呢其实在 Linux 当中的命令当中页使用到了 who | wc -l 输出 因为指令其实就是一个一个的可执行程序像上述例子就是 who 这个进程先加载然后把 who 进程的输出结果保存到管道当中此时 wc 可执行程序在变成进程最后把 who 和 wc 两个进程的执行的结果 结合在一起。 所以管道其实就是在上述的过程当中在内存当中模拟实现的一个过程在磁盘当中我们是按照一个 文件的方式来进行存储的一个文件由自己的文件属性inode由操作底层硬件的方法集还有在内存当中存储的缓冲区。 那么有人就想既然在磁盘上对于此磁盘的操作在效率上不讨好那么在 内存当中我们其实也可以 利用在磁盘当中对于文件的管理方式来 在内存当中划分出一块区域使用管理文件的方式来管理这个块区域。 使用文件的方式来管理内存当中的某一块区域管理的这一块区域我们就称之为 --- 内存级文件。 所以因为 内存级文件虽然本质上是文件虽然用户可以看到但是实际上是在内存当中存储数据的。 所以在磁盘当中我们需要有一个 在内存上存储的一个 缓冲区用于 内存和 磁盘上的交互但是对于内存级文件就不存在了。因为 内存级文件的存储区域就是在内存上的。 对于父子进程子进程会继承父进程当中的 file_struct 结构体对象这个结构体对象当中存储了 当前进程 所打开的 所有文件的 文件对象 的数组struct file *fd_array[]。这个数组的下标就是 文件的对应的 fd 文件描述符。 对于 file_struct 结构体相当于是子进程会直接拷贝一份一模一样的 file_struct 供自己使用。 但是对于 struct_file 这个文件的文件对象子进程是不会拷贝的。这也好理解文件是可以被多个进程访问一个 文件对象就已经够 操作系统管理 这些个文件了。 所以对于 文件对象还有缓冲区这些属于文件的 “内容” 子进程 创建这些 属于文件的 “内容” 是不会拷贝的自始至终都只会是一个。 所以其实子进程和父进程之间看到访问到修改到的都是同一些文件。 也就是说只要子进程或者父进程自己不 打开 / 关闭 文件那么两者之前访问的文件都是一样的甚至连 文件的 fd 文件描述符都是一样的。 而上述说过了进程通信的本质就是 要让 两个进程可以访问同一块 “资源” 像上述fd 为 3 的文件就是父子进程 所共同访问的 文件资源了。所以其实管道就是文件。 但是你可以发现一个问题如果在父进程当中打开上述的共享文件 的方式是只写的那么子进程也应该继承的是只写的如果是只读的那么子进程也应该是只读的。 我们进程之间的通信的话是一个读 一个写的这个不就矛盾了吗 确实矛盾了此时就有人想那么把父进程打开这个共享文件的方式改为 以读写的方式打开的不就可以了吗 虽然此时子进程继承的 打开方式也是读写了的但是 管道在设计之初并没有把打开的方式设计为 可读可写的。 所以父进程在打开这个共享文件就不能想上述一样按照只读的方式或者是按照 只写的方式打开了。 我们接下来看 管道的原理 管道的原理 所以管道不给我们以 可读可写的方式打开的话那么我们 分别以 读的方式 和 写的方式两次打开同一个文件不就可以了吗 此时创建子进程的话也是和父进程一样由两种方式打开同一个文件   然后对于通信的发送方 假定是 父进程接收方是 子进程的话那么父子进程只需要保留自己需要的 打开访问的方式的 fd 文件描述符即可另一个就可以关闭了。比如父进程是发送方那么只需要保留 以 写的方式 打开的文件的 fd另一个 以 读的方式打开的文件的 fd 就可以关闭了   这时在父子进程之间就建立了一种 单向的通信信道。 为什么管道不支持 以 可读可写的方式打开文件呢 我们拿 这个例子距离 假设现在我们拿 struct file* fd_array[] 数组当中的两个 fd 文件描述符 指向同一个 以 r 的方式打开的文件的 文件对象的话。 因为一个文件对象 struct file操作系统用来管理文件的存储文件属性的结构体对象当中由变量存储的是 访问文件的字符串指针这个指针指向当前 文件对象 访问文件当中的那一个位置。 那么 如果是 两个 fd 文件描述符 指向同一个 以 r 的方式打开的文件的 文件对象的话就会发生冲突上一个 fd 访问到某一个位置那么另一个fd 在访问之时就是从上一次访问的位置开始访问而可能不是从开始位置访问。 所以像上述父进程当中用两种方式分别 打开同一个文件创建两个 fd 的操作相当于是此时有两个 文件对象 当中 指向缓冲区的指针 指向 指向同一个缓冲区。一个是 以 只读的方式打卡的一个是以 只写的方式打开的。 所以两个文件对象虽然访问的是同一个 缓冲区但是在缓冲区当中访问字符串的指针指向是不一样的。 而父子进程之间在设计两者之间的 通信的时候就是要让 两者之间实现单向通信。为什么呢 因为 为了简单单向通信就够用了不需要再设计双向通信了。 同样的操作系统在实现进程之间通信就是为了简单所以直接使用文件系统来进行复用。而不是像之前的 进程管理文件系统一样再设计一套 宏大的 结构体数据结构来进行管理。 所以像上述这种单向通信由一个入口和一个出口这种我们就把他称之为 --- 管道。 如果要建立双向通信的话其实就是多一个 反向的 管道。 所以上面大篇文章当中都说的是  父子进程之间的通信。 如果两个进程之间没有任何关系的话以上述的通信原理两个进程之间可不可进行通信呢 一般是不可以的。如果两个进程之间没有关系一般是不能 以上述的通信原理 进行通信的。 我们在下篇博客当中会说到匿名管道但是这种管道使用比较特殊 要使用上述的方式去通信的话进程之间必须是父子关系。 而可能父进程创建的 子进程不止一个。子进程之间也就是兄弟进程之间也是可以进行通信的。 而且如果 子进程 也创建了 它的 子进程那么子进程的子进程 和 父进程之间也就是 爷爷 和 孙子 进程 之间也是可以进行通信的。 结论进程间的通信只能用于 由 血缘关系的进程之间的通信只不过常用与 父子进程的通信。 通信的系统调用接口 我们在C 语言当中的打开文件是使用 open函数打开 一个文件的但是使用 open函数打开一个文件这个文件是 磁盘文件因为在open函数当中是需要带上文件的 路径的。 所以如果想要打开 内存文件 的话需要 pipe这个函数实现。 这个 pipe 函数 的意思就是 创建一个 管道。 返回值 如果创建成功返回0如果创建失败返回-1同时 errno错误码被设置 参数pipefd[2] 其实在 C 语言传参当中数组的传参可以是 arr[] 的方式在 [] 当中是不需要带上数字的因为带上编译也会直接忽略掉。此时带上这个 2 就是像提醒你传入的数组只需要两个元素。 这个 参数是说一个数组这个数组有两个元素而且这个参数是一个输出性参数。 这个输出型参数当中存储的数据就是我们上述所说的 fd[0] 和 fd[1] 也就是 一个用于 发送方发送数据 所用到的 fd 文件描述符另一个是 接收方 接受数据所使用的 fd 文件描述符。 在 pipefd 数组当中 pipefd[0] 读下标 pipefd[0] 写下标  凡是在 0 号下标位置的 fd 对应的文件就是 接收方使用的文件1 号下标位置的fd 对应的文件就是 发送方使用的文件。 #includeiostream #includeunistd.husing namespace std;int main() {int pipefd[2] {0};int n pipe(pipefd);if(n 0) return 1; // 出错返回1cout pipefd[0] : pipefd[0] \npipefd[1] : pipefd[1] endl;return 0; } 输出   模拟父子进程间通信 此时上述其实就是已经为什么创建好了内存文件了然后我们来模拟一些 父子之间的 通信 我们可以使用 sprintf和 snprintf函数printf函数format 参数就是格式化输出的字符串参数就会往显示器文件上打印 这个 format 结果 ... 可变参数包当中的 格式化之后的字符串。 sprintf函数会在 str 这个 字符串 参数其实可以看做是缓冲区当中复制拷贝一份在 str 当中。 snprintf和 sprintf也是一样的只是这个 str 的最大长度是 size。也就是一个安全的格式化接口。 #include iostream #include cstdio #include string #include cstring #include cstdlib //stdlib.h #include unistd.h #include sys/types.h #include sys/wait.h#define N 2 #define NUM 1024using namespace std;// child void Writer(int wfd) {string s hello, I am child;pid_t self getpid();int number 0;char buffer[NUM];while (true){sleep(1);// 构建发送字符串buffer[0] 0; // 字符串清空, 只是为了提醒阅读代码的人我把这个数组当做字符串了snprintf(buffer, sizeof(buffer), %s-%d-%d, s.c_str(), self, number);// cout buffer endl;// 发送/写入给父进程, system callwrite(wfd, buffer, strlen(buffer)); // strlen(buffer) 1???cout number endl;} }// father void Reader(int rfd) {char buffer[NUM];while(true){buffer[0] 0; // system callssize_t n read(rfd, buffer, sizeof(buffer)); //sizeof ! strlenif(n 0){buffer[n] 0; // 0 \0cout father get a message[ getpid() ]# buffer endl;}else if(n 0) {printf(father read file done!\n);break;}else break;// cout n: n endl;} }int main() {int pipefd[N] {0};int n pipe(pipefd);if (n 0)return 1;// cout pipefd[0]: pipefd[0] , pipefd[1]: pipefd[1] endl;// child - w, father-rpid_t id fork();if (id 0)return 2;if (id 0){// childclose(pipefd[0]);// IPC codeWriter(pipefd[1]);close(pipefd[1]);exit(0);}// fatherclose(pipefd[1]);// IPC codeReader(pipefd[0]);pid_t rid waitpid(id, nullptr, 0);if(rid 0) return 3;close(pipefd[0]);sleep(5);return 0; } 输出 我们在上述代码当中子进程的代码块并没有像屏幕上输出任何的消息只有父进程向屏幕上打印了消息。 子进程只是把自己的消息一次一次的往 共享文件当中写入当 父进程 调用 read 函数读取共享文件当中的内容然后把 读取到的内容输出到 显示器文件当中。 子进程 一次次的 写入父亲进程 就会一直读取输出到 屏幕上。 思考 进程间通信的意义 在 之前谈到 父子进程的博客的当中我们说过父子进程 使用 if 语句分开的 代码块同样可以访问到 之前共享的 局部变量和 全局变量。 也就是说如果我们在 全局当中定义一个字符串那么这个字符串不管是 父进程还是 子进程都是可以拿到的那么为什么要像上述代码当中大费周章的 创建一个共享文件也就是创建一个管道来实现的 父子进程间的通行的呢 实际上像我们上述所说的 之前共享的 局部变量和 全局变量像全局变量当中的字符串都是属于 静态数据而 共享的局部变量虽然不是静态数据但是这两者只要是 父子进程其中任何一个 进程 进行了修改都会发生写时拷贝。 此时那么两者就不可能进行通信。 而像上述访问内存级的文件为什么不能使用 C 库当中的文件操作函数接口比如是 fopen这些函数呢 因为操作系统不相信任何人。我们上述的父进程 和 子进程操作系统怎么敢让 除自己之外的进程 直接访问到 内存当中的数据呢 万一 这个进程直接向 内存当中 写入病毒或者是把 内存写满了 操作系统释放都不好释放怎么办 所以操作系统就告诉 进程你要想访问内存必须使用我提供的 系统调用接口如上述所使用的 writeread这个系统调用接口 来访问 内存数据。 在上述例子的 子进程 代码块当中我们使用 buffer 这个字符串数组来存储 要格式化的 字符串信息然后在使用 write函数 把buffer 当中的字符串拷贝到 共享文件当中。 所以像上述的 buffer 这个字符串 就相当于是 用户级缓冲区。 而我们上述调用 write函数就相当于是 把 buffer 缓冲区当中的数据 刷新到 文件当中。 而在父进程当中也有一个 buffer数组使用 read函数把 文件当中的数据拷贝到 buffer 数组当中也相当于是把 文件当中的数据 拷贝到 buffer 这个用户级缓冲区当中。 向上述在 Reader 函数当中父进程并没有 sleep但是子进程 sleep 了。你可能会以为当子进程sleep 之时父进程 会一直读读完就结束了。 其实并不是当你把 子进程当中 sleep 的秒数加到 50 秒你会发现子进程每隔50秒往共享文件当中输出信息但是父进程没有一直再读然后直接结束而是等待 子进程的输入 这说明父子进程之间是会进行 协同的。 我们进行进程之间的通信的时候本质其实就是 让不同进程看到同一块资源但是如果是共享资源的话就会带来一个问题就是抢资源的问题。 也就是难免会出现访问冲突的问题临界资源竞争的问题。 父子进程会进行 同步于互斥  --- 保护管道文件数据的安全。 而管道是有自己的大小的如果我们让 父进程 等待 子进程把 共享文件写满才进行读取的话。如果父进程当中的 buffer 数组是足够大的那么他会一次把数据全部读取完。 也就是说不管子进程当中分多少次 写入的数据父进程在读取之时只是无脑的 直接把数据全部读取出来。 这就是 管道是面向字节流的这个特性。 也就说管道看到的只是在文件当中存储的字符他看到的只是字符所以它只会直接把 管道当中的数据直接读取出来至于这个字符应该怎么分割由用户去做。 验证 管道的大小  使用 ulimit -a 命令 查看操作系统当中对于 很多重要资源的一种限制。 因为管道是基于文件的所以像上述的 以r 方式打开的 文件对象 和 以w 方式打开的 文件对象 的引用计数都是1。 当父子进程退出之时因为这两个文件对象的 引用计数都是1 所以就算我们不进行关闭操作系统也会帮我们进行关闭。 所以管道是基于文件的而文件的生命周期是随着进程的。 就像我们默认打开了  0,1,2  这三个标准输入输出文件但是我们在最后并没有进行关闭因为操作系统会帮我们自动关闭。 管道当中的四种情况 如果读写端是正常的管道如果为空读端就要进行阻塞。 读写端正常管道如果被写满了写端也要进行阻塞。 读端正常读写端关闭读端就会读到0表明读到了文件的pipe结尾不会被阻塞。 #include iostream #include cstdio #include string #include cstring #include cstdlib //stdlib.h #include unistd.h #include sys/types.h #include sys/wait.h#define N 2 #define NUM 1024using namespace std;// child void Writer(int wfd) {string s hello, I am child;pid_t self getpid();int number 0;char buffer[NUM];while (true){sleep(1);// 构建发送字符串//buffer[0] 0; // 字符串清空, 只是为了提醒阅读代码的人我把这个数组当做字符串了//snprintf(buffer, sizeof(buffer), %s-%d-%d, s.c_str(), self, number);// cout buffer endl;// 发送/写入给父进程, system call//write(wfd, buffer, strlen(buffer)); // strlen(buffer) 1???char c c;write(wfd, c, 1); // strlen(buffer) 1???number;cout number endl;if(number 5) break;} }// father void Reader(int rfd) {char buffer[NUM];while(true){buffer[0] 0; // system callssize_t n read(rfd, buffer, sizeof(buffer)); //sizeof ! strlenif(n 0){buffer[n] 0; // 0 \0cout father get a message[ getpid() ]# buffer endl;}else if(n 0) {printf(father read file done!\n);break;}else break;// cout n: n endl;} }int main() {int pipefd[N] {0};int n pipe(pipefd);if (n 0)return 1;// cout pipefd[0]: pipefd[0] , pipefd[1]: pipefd[1] endl;// child - w, father-rpid_t id fork();if (id 0)return 2;if (id 0){// childclose(pipefd[0]);// IPC codeWriter(pipefd[1]);close(pipefd[1]);exit(0);}// fatherclose(pipefd[1]);// IPC codeReader(pipefd[0]);pid_t rid waitpid(id, nullptr, 0);if(rid 0) return 3;close(pipefd[0]);sleep(5);return 0; } 管道当中读取必须是 原子性的 也就是说上述父进程在读取之时必须以 4096bytes 来读取比如子进程 输入了一个 helloworld 字符串当 在子进程写完一个 hello 父进程就直接把这个hello 读走了这是不行的。 所以需要规定父进程必须以   helloworld 这个字符串 为一次读取也就是说要么一次读取 一个 helloworld 字符串要么就不读。