建站行业如何快速成第一单,做网站怎么套用模板,wordpress 群聊汉化版插件,网站访问量咋做目录
1. VSCode环境安装
1.1 使用VSCode
1.2 远程链接到Linux机器
1.3 VSCode调试
2. 进程间通讯介绍
2.1 进程间通讯的概念和意义
2.2 进程间通讯的策略和本质
3. 管道
3.1 管道介绍
3.2 匿名管道介绍
3.3 匿名管道示例代码
3.3.1 建立管道的pipe
3.3.2 匿名管道…目录
1. VSCode环境安装
1.1 使用VSCode
1.2 远程链接到Linux机器
1.3 VSCode调试
2. 进程间通讯介绍
2.1 进程间通讯的概念和意义
2.2 进程间通讯的策略和本质
3. 管道
3.1 管道介绍
3.2 匿名管道介绍
3.3 匿名管道示例代码
3.3.1 建立管道的pipe
3.3.2 匿名管道完整代码
3.3.3 匿名管道模拟进程池
3.4 命名管道介绍
3.4.1 命名管道概念
3.4.2 mkfifo和unlink小实验
3.5 命名管道示例代码
3.5.1 系统调用的mkfifo和unlink
3.5.2 命名管道示例完整代码
4. 笔试选择题
答案及解析
本篇完。 1. VSCode环境安装
下载可以在官网直接下载慢的话可以直接复制这个链接
https://vscode.cdn.azure.cn/stable/30d9c6cd9483b2cc586687151bcbcd635f373630/VSCodeUserSetup-x64-1.68.1.exe
安装很简单可以自己安装一下不行就搜一搜。
1.1 使用VSCode
VSCode至少是一个编辑器和Vim一样。 刚打开应该是英文的点击左边应用搜索chinese直接安装简体中文就行。 在桌面创建一个空文件夹然后在VSCode中点击打开文件夹选择桌面选择刚创建的文件夹打开就行。然后这里选择新建文件 这里新建test.c文件此时右下角可能会有安装C/C的插件等安装就行。
左下角设置可以修改字体大小写一段代码Ctrl s保存 再新建一个test.cpp文件写一段代码并Ctrl s保存然后顺便创建一个文件夹试试 也可以创建其它语言的文件此时桌面刚才新建的文件夹就有了在VSCode创建的东西 运行是运行不了的这里远程链接我们前面使用的Linux机器也可以用其它方法
1.2 远程链接到Linux机器
在应用里搜索Remote并安装滑下来你可以看到步骤 这里按F1键选中Remote-SSH Add输入ssh 你的用户名你的公网IPxshell登录可以看 回车后按第一行就配置好了这里可以关掉重新启动VSCode然后左边的远程资源管理器就出现了你刚才链接的机器。 这里右键机器然后选择上面一行的在当前窗口链接然后选择Linux输入刚才用户名密码 然后这里打钩了就是链接好了 这里打开xshll在平时写代码的路径创建一个TestVSCode目录 点击左上角的资源管理器新建文件夹默认就是我们在xshell的路径 选择TestVSCode目录确定选择Linux然后输密码就行
这里连接好了新建一个test.cpp文件写点代码Ctrl S保存 此时在xshell就自动同步我们的文件和代码了编译运行试试 你也可以在VSCode下 Ctrl ~ 调出终端输入命令 成功成功。 1.3 VSCode调试
C相关的插件刚才应该也一带安装了没安装的这里打钩都能安装了 这里安装下GDB Debug然后在左边类似小爬虫的图标上点击这里 然后选择GDB Debug调试器
这个小方括号里面的内容都可以删掉了然后点击左边的添加配置选择第一行什么gdb 启动 然后只需要改这一行program: 输入程序名称例如 ${workspaceFolder}/a.out,
改成program: ${workspaceFolder}/test_gdb,
Ctrl 保存在终端生成test_gdb调试文件运行 然后在点小爬虫左上角的开始调试F5就行快捷键都和VS2022差不多的 断点也能直接打左边变量啥的都能看到但是VSCode的调试有时会很卡所以不常用
据此VSCode的简单使用就讲完了。 2. 进程间通讯介绍
IPCInter-Process Communication进程间通讯
2.1 进程间通讯的概念和意义 什么是进程间通信 进程间通信是两个或者多个进程之间进行通信行为如下 数据传输一个进程需要将它的数据发送给另一个进程。资源共享多个进程之间共享同样的资源。通知事件一个进程需要向另一个或一组进程发送消息通知它它们发生了某种事件如进程终止时要通知父进程。进程控制有些进程希望完全控制另一个进程的执行如Debug进程此时控制进程希望能够拦截另一个进程的所有陷入和异常并能够及时知道它的状态改变。 为什么要进行通信 我们在之前讲过 进程之间是具有独立性 的如果进程间想交互数据成本会非常高。 因为独立性之本质即 封闭进程们你封闭你的我封闭我的那么进程间的交流可谓是窒碍难行。 进程间的通信说白了就是 数据交互在操作系统中进程是独立运行的程序它们之间需要相互协作完成任务。进程间通信的目的是为了实现进程之间的数据共享、协作和同步从而提高系统的效率和可靠性。 很多场景下我们需要多进程进行协同处理一件事情。 不要以为进程独立了就是彻底独立有时我们需要双方能够进行一定程序的信息交互。 2.2 进程间通讯的策略和本质 如何进行进程通信 当前主要是通过三种策略来实现进程间通信的每一种策略下都有很多种通信方式 ① 管道通过文件系统通信。 匿名管道 命名管道 ② System Ⅴ聚焦在本地通信。 共享内存 消息队列 信号量 ③ POSIX让通信可以跨主机。 共享内存 消息队列 信号量 互斥量 条件变量 读写锁 进程通信的本质是什么 我们知道进程是相互独立的所以进程之间的通信成本肯定不低。 为了进程在通信的时候既能满足进程之间的独立性又能够到达通信的目的那么进程之间通信的地点就不能在两个进程中。 一个进程将自己的数据交给另一个进程并且还要等待另一个进程的应答这样一来这个进程将不独立了受到了另一个进程的影响与进程的独立性矛盾。 所以两个进程进行通信的地点必须是由第三方提供的第三方只能是操作系统。操作系统提供的这个地点被我们称为公共资源。 公共资源有了还必须让要通信的进程都看到这一份公共资源此时要通信的进程将有了通信的前提。之后就是进程通信也就是访问这块公共资源的数据。 之所以有不同的通信方式是因为公共资源的种类不一如果公共资源是一块内存那么通信方式就叫做共享内存如果公共资源是一个文件也就是struct file结构体那么就叫做管道。 3. 管道
3.1 管道介绍
什么是管道管道是 Unix 系统中最古老的 IPC 形式
一个进程连接到另一个进程的数据流称为管道 (Pipe)。
我们来回忆一下文件系统 父进程打开一个文件操作系统在内存上创建一个struct file结构体对象里面包含文件的各种属性以及对磁盘文件的操作方法。每个struct file对象中还有一个内核缓冲区这个缓冲区中可以存放数据。当子进程创建的时候父进程的文件描述符表会被子进程继承下去所以此时子进程在相同的fd处也指向父进程打开的文件。文件描述符表一个进程维护一个但是struct file结构体对象在内存中只有一个由操作系统维护。此时父子进程将看到了同一份公共资源也就是操作系统在内存中维护的struct file对象并且父子进程也都和这份资源建立了连接。此时父子进程通信的基础有了它们就可以通信了。 父进程向文件中写内容写完后继续干自己的事并不破坏父进程的独立性。 子进程向文件中读内容读完后继续干自己的事并不破坏子进程的独立性。 这样一读一写父子进程将完成了一次进程间通信。 而我们又知道对文件进行IO操作时由于需要访问硬盘所以速度非常的慢而且我们发现父子间进行通信磁盘中文件的内容并不重要重要的是父进程写了什么子进程又读到了什么。 此时操作系统为了提高效率就关闭了内存中struct file和硬盘中文件进行IO的通道。 父进程写数据写到了struct file的内核缓冲区中。 子进程读数据从struct file的内核缓冲区中读取。 此时父子间通信仍然正常进行并且效率还非常的高而且还没有影响进程的独立性。而这种不进行IO的文件叫做内存级文件。 这种由文件系统提供公共资源的进程间通信就叫做管道。 两个进程就通过管道建立起了连接并且可以进程进程之间的通信。而管道又分为匿名管道和命名管道。 3.2 匿名管道介绍
匿名管道顾名思义就是没有名字的文件(struct file)。匿名管道只能用于父子进程间通信或者由一个父进程创建的兄弟进程之间进行通信。 现在我们知道了匿名管道就是没有名字的文件通过管道进行通信时只需要通信双方打开同一个文件就可以。 我们通过系统调用open打开文件的时候会指定打开方式是读还是写。 当父进程以写方式打开一个文件的时候创建的子进程会继承父进程的一切。 此时子进程也是以写的方式打开的这个文件。既然是通信势必有一方在写一方在读而现在父子双方都是以写的方式打开它们怎么进行通信呢父进程以读和写的方式打开同一份文件两次。 这样一来创建子进程后父子进程都可以对管道进行读和写它们就可以进行通信了上面的问题就解决了。之所以命名为管道那么就有和管道类似的性质。在生活中我们对水管它的流向只能是单向的管道也一样通过管道建立的通信只能进行单向数据通信。
如上图假设父进程对管道写子进程对管道读。
为了防止父进程对管道进行误读以及子进程对管道进行误写破坏通信规则。将父进程的读端关闭将子进程的写端关闭使用系统调用close(fd)。
此时父子进程之间的单向数据通信就建立起来了下一步就可以进行通信了。如果想进行双向通信可以建立两个管道。 3.3 匿名管道示例代码
示例从键盘读取数据写入管道读取管道写到屏幕。
这里在rtx2目录下新建一个linux_17目录在里面新建一个pipe目录在VSCode写代码 前面弄好了VSCode没弄好用Vim写也行打开VSCode打开上面的pipe文件夹链接输普通用户的密码写个Makefile 3.3.1 建立管道的pipe
上面都是理论上的具体到代码中是如何建立管道的呢
既然是操作系统中的文件系统提供的公共资源当然是用系统调用来建立管道了。 原型 int pipe(int pipefd[2]); #include unistd.h 功能:创建一个匿名管道 形参int pipefd[2]是一个输出型参数一个数组该数组只有两个元素下标分别为0和1。 下标为0的元素表示的是管道读端的文件描述符fd。 下标为1的元素表示的是管道写端的文件描述符fd。 这里巧记pipefd[0(嘴巴读书)]: 读端 , pipefd[1(钢笔写)]: 写端 返回值返回0管道创建成功。返回-1管道创建失败并将错误码自动写入errno中。 使用系统调用pipe直接就会得到两个fd并且放入父进程的文件描述符表中不用打开内存级文件两次。那么父进创建管道以后得到的两个文件描述符是多少呢根据前面所学是3和4吗我们代码中来看mypipe.cpp
#include iostream
#include cerrno // C包C语言头文件常用的方法,和.h效果一样
#include cstring
#include unistd.h // pipeusing namespace std;int main()
{int pipefd[2];int ret pipe(pipefd); // 一.创建管道if(ret 0){cerr errno : strerror(errno) endl;}cout pipefd[0]: pipefd[0] endl; // 3cout pipefd[1]: pipefd[1] endl; // 4return 0;
} 可以看到创建管道后返回的两个fd值果然是3和4因为0,1,2分别被stdinstdoutstderr占用。知道了如何使用系统调用创建管道以后接下来就创建子进程然后关闭不需要的端口了原理已经清楚直接看代码。
#include iostream
#include cerrno // C包C语言头文件常用的方法,和.h效果一样
#include cstring
#include cassert
#include unistd.h // pipe closeusing namespace std;int main()
{int pipefd[2];int ret pipe(pipefd); // 一.创建管道if(ret 0){cerr errno : strerror(errno) endl;}// cout pipefd[0]: pipefd[0] endl; // 3// cout pipefd[1]: pipefd[1] endl; // 4pid_t id fork(); // 二.创建子进程assert(id ! -1);if (id 0) // 子进程读关闭写{close(pipefd[1]);// 通信close(pipefd[0]);exit(0);}close(pipefd[0]); // 父进程写关闭读// 通信close(pipefd[1]);return 0;
}
此时在代码层面上 父子双方就已经建立了连接了接下来就是通信数据了。
子进程读代码 父进程写代码 3.3.2 匿名管道完整代码
#include iostream
#include cerrno // C包C语言头文件常用的方法,和.h效果一样
#include cstring
#include cassert
#include unistd.h // pipe close read write
#include sys/types.h // waitpid两个头文件
#include sys/wait.husing namespace std;int main()
{int pipefd[2];int ret pipe(pipefd); // 一.创建管道if(ret 0){cerr errno : strerror(errno) endl;}// cout pipefd[0]: pipefd[0] endl; // 3// cout pipefd[1]: pipefd[1] endl; // 4pid_t id fork(); // 二.创建子进程assert(id ! -1);if (id 0) // 子进程读关闭写{close(pipefd[1]);// 三. 子进程读char buffer[1024 * 8];while (true){// sleep(10);ssize_t s read(pipefd[0], buffer, sizeof(buffer) - 1); // read读if (s 0) // 写入的一方fd没有关闭如果有数据就读没有数据就等{buffer[s] 0;cout child get a message[ getpid() ] Father# buffer endl;}else if (s 0) // 写入的一方fd关闭, 读取的一方read会返回0表示读到了文件的结尾{cout writer quit(father), me quit endl;break;}}close(pipefd[0]);exit(0);}close(pipefd[0]); // 父进程写关闭读// 四. 父进程写string message 我是父进程我正在给你发消息;int count 0;char send_buffer[1024 * 8];while (true){//构建一个变化的字符串snprintf(send_buffer, sizeof(send_buffer), %s[%d] : %d,message.c_str(), getpid(), count);write(pipefd[1], send_buffer, strlen(send_buffer)); // 写入sleep(1);cout count endl;if (count 5) {cout writer quit(father) endl;break;}}close(pipefd[1]);pid_t ret_id waitpid(id, nullptr, 0);cout id : id ret_id: ret endl;assert(ret_id 0); // 断言只在debug起效(void)ret_id; // 只是证明ret_id被使用过return 0;
} 这就实现了简单的匿名管道。
可以自己改代码试一试管道的读取特征
场景特征读取慢写入快写入端阻塞在write处读取快写入慢读取端阻塞在read处读取端关闭操作系统终结写端写入端关闭读取端read返回0 管道之所以有这样的读取特征其实是为了对管道中的数据进行保护这种方式称为互斥后面会详细讲解这一概念。 匿名管道本身也有它自己的特征如下 管道的生命周期随进程的结束而结束当所有进程都关闭该管道的文件描述符时管道被销毁。管道可以用来进行具有血缘关系的进程之间进行通信常用于父子进程通信。管道是半双工的通信方式单向通信管道是面向字节流的在网络部分讲解。管道有互斥与同步机制对共享资源进行保护以后讲解。 3.3.3 匿名管道模拟进程池
这里在linux_17目录下创建ProcessPool目录在VSCode打开在里面写代码
直接放匿名管道模拟进程池的代码了可以自己跟着注释读一遍也可以跟着写一写
Makefile
ProcessPool:ProcessPool.cppg -o $ $^ -stdc11
.PHONY:clean
clean:rm -f ProcessPool
ProcessPool.cpp
#include iostream
#include vector
#include cstdlib
#include ctime
#include cassert
#include unistd.h
#include sys/wait.h
#include sys/types.h
#include Task.hpp // 发任务的文件.hpp - .h和.cpp写一起#define PROCESS_NUM 5 // 创建的子进程数目using namespace std;int waitCommand(int waitFd, bool quit) //如果对方不发我们就阻塞
{uint32_t command 0; // uint32_t四个字节ssize_t s read(waitFd, command, sizeof(command)); // 期望读取四个字节if (s 0) // 读到0让子进程退出{quit true;return -1;}assert(s sizeof(uint32_t)); // 不是四个字节就报错return command;
}void sendAndWakeup(pid_t who, int fd, uint32_t command) // 通过文件描述符向哪一个文件发什么命令
{ // who给哪个进程这个进程的idwrite(fd, command, sizeof(command));cout main process: call process who execute desc[command] through fd endl;
}int main()
{// 代码中关于fd的处理有一个小问题不影响我们使用但是你能找到吗load();vectorpairpid_t, int slots; // 存放子进程pid和子进程写端id(pipefd)vectorint deleteFd; // 存放要删除的子进程写端fd(不删除也不会出问题)for (int i 0; i PROCESS_NUM; i) // 先创建多个进程{int pipefd[2] { 0 };int ret pipe(pipefd); // 创建管道assert(ret 0); // 等于0才创建成功(void)ret;pid_t id fork();assert(id ! -1);if (id 0) // 子进程进行读取{close(pipefd[1]); // 关闭写端for (int i 0; i deleteFd.size(); i) // 关闭所以继承下来的写端fd{close(deleteFd[i]);}while (true){// 等命令bool quit false; // 默认不退出int command waitCommand(pipefd[0], quit); // 如果对方不发我们就阻塞if (quit) // 读到0就退出关闭所有进程{break;}if (command 0 command handlerSize()) // 执行对应的命令{ // handlerSize任务方法的个数callbacks[command]();}else{cout 非法command: command endl;}}exit(1);}close(pipefd[0]); // 父进程进行写入关闭读端slots.push_back(pairpid_t, int(id, pipefd[1])); // 把此次循环得到的子进程id和子进程写端的id保存deleteFd.push_back(pipefd[1]); // 把要被继承下去的子进程写端fd保存起来}// 父进程均衡地派发任务单机版的负载均衡srand((unsigned long)time(nullptr) ^ getpid() ^ 2335643123L); // 仅仅让数据源更随机while (true){// 选择一个任务int command rand() % handlerSize();// 选择一个进程 采用随机数的方式选择进程来完成任务随机数方式的负载均衡int choice rand() % slots.size();// 把任务给指定的进程sendAndWakeup(slots[choice].first, slots[choice].second, command);sleep(1);//int select; // 手动版//int command;//cout ############################################ endl;//cout # 1. show funcitons 2.send command # endl;//cout ############################################ endl;//cout Please Select ;//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 // 选择错误//{//}}for (const auto slot : slots) // 关闭fd, 所有的子进程都会退出{close(slot.second);}for (const auto slot : slots) // 回收所有的子进程信息{waitpid(slot.first, nullptr, 0);}
}
Task.hpp
#pragma once#include iostream
#include string
#include vector
#include unordered_map
#include unistd.h
#include functionaltypedef std::functionvoid() func;std::vectorfunc callbacks; // 存放若干个回调
std::unordered_mapint, 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: 读取数据库 });callbacks.push_back(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; // \t制表符}
}int handlerSize() // 直接返回有多少个任务的方法
{return callbacks.size();
}
编译运行 3.4 命名管道介绍
3.4.1 命名管道概念
命名管道顾名思义有名字的管道(内存级文件)。
根据前面的学习我们知道父子进程间使用匿名管道的方式进行通信是通过子进程继承父进程的方式来实现而且匿名匿名管道常用于父子进程直接或者由血缘关系的进程直接。
那么如果两个进程毫无关系呢此时就不能继承了那这两个进程如何建立连接呢
还是采用管道的方式但是这个管道是有名字的管道这样一来两个进程就可以打开同一个管道文件建立连接。 还是这张图此时内存中的struct file在磁盘上有对应文件的如上图中的fifo.ipc文件。
3.4.2 mkfifo和unlink小实验
创建命名管道指令man mkfifo 指令mkfifo 文件名功能创建命名管道文件
FIFOfirst in first out因为管道是单向通信的这里在linux_17目录下创建fifo目录进入并建立一个命名管道 此时就成功地建立了一个命名管道可以发现它的文件类型权限前面的字母是ppipe而目录的文件类型是ddirectory。命名管道文件类型是p而且该文件还有inode说明在磁盘上是真实存在的。 当磁盘中有了命名管道文件以后两个进程将可以通过这个管道文件进行通信了步骤和匿名管道非常相似。一个进程以写方式打开管道文件另一个进程以读端方式打开管道文件。此时两个进程将建立了连接然后将可以进行通信了。我们知道进程间通信的前提是要通信的进程能够看到同一份公共资源那么命名管道是如何做到这一点的呢
让不同的进程打开指定路径下同一个管道文件。 往name_pipe写点东西 此时发现类似堵塞住了 此时处于的就是阻塞状态它需要被另一个进程读取 此时就相当于完成了两个进程之间的通讯。
你可以通过unlink或者rm删掉命名管道效果是差不多的man unlink 3.5 命名管道示例代码
3.5.1 系统调用的mkfifo和unlink
可以在shell中通过命令的方式创建管道文件两个进程直接去使用它。也可以像文件一样在进程中创建管道文件此时就需要用到系统调用。man 3 mkfifo 第一个形参管道文件的名字第二个形参创建管道文件的权限返回值0表示创建成功-1表示创建失败。
在进程中删除管道文件man 2 unlink 写个测试代码 如果带上unlink 此时命名管道在进程里打开也在进程里关闭了。 3.5.2 命名管道示例完整代码
在VSCode打开上面的fifo文件夹在里面写代码
Makefile
.PHONY:all
all:client mutiServerclient:client.cppg -o $ $^ -stdc11
mutiServer:server.cppg -o $ $^ -stdc11.PHONY:clean
clean:rm -f client mutiServer
comm.hpp一些头文件和宏和一个路径
#ifndef _COMM_H_
#define _COMM_H_#include iostream
#include string
#include cstdio
#include cstring
#include unistd.h
#include sys/types.h
#include sys/stat.h
#include fcntl.h
#include sys/wait.h
#include Log.hppusing namespace std;#define MODE 0666
#define SIZE 128string ipcPath ./fifo.ipc;#endif
Log.hpp打印日志不加也行
#ifndef _LOG_H_
#define _LOG_H_#include iostream
#include ctime#define Debug 0
#define Notice 1
#define Warning 2
#define Error 3const std::string msg[] {Debug, Notice, Warning, Error};std::ostream Log(std::string message, int level)
{std::cout | (unsigned)time(nullptr) | msg[level] | message;return std::cout;
}#endif
server.cpp服务端
#include comm.hppstatic void getMessage(int fd) // 读取信息
{char buffer[SIZE];while (true){memset(buffer, \0, sizeof(buffer));ssize_t s read(fd, buffer, sizeof(buffer) - 1);if (s 0) // 读取成功{cout [ getpid() ] client say buffer endl;}else if (s 0) // 文件结尾end of file{cerr [ getpid() ] read end of file, clien quit, server quit too endl;break;}else // 读取失败{perror(read);break;}}
}int main()
{if (mkfifo(ipcPath.c_str(), MODE) ! 0)// 1. 创建管道文件{perror(mkfifo);exit(1);}Log(创建管道文件成功, Debug) step 1 endl;int fd open(ipcPath.c_str(), O_RDONLY); // 2. 正常的文件操作if (fd 0){perror(open);exit(2);}Log(打开管道文件成功, Debug) step 2 endl;int nums 3;for (int i 0; i nums; i){pid_t id fork();if (id 0) // 3. 编写正常的通信代码{getMessage(fd); // 读取信息exit(1);}}for (int i 0; i nums; i){waitpid(-1, nullptr, 0);}close(fd); // 4. 关闭文件Log(关闭管道文件成功, Debug) step 3 endl;unlink(ipcPath.c_str()); // 通信完毕就删除文件Log(删除管道文件成功, Debug) step 4 endl;return 0;
}
client.cpp用户端
#include comm.hppint main()
{int fd open(ipcPath.c_str(), O_WRONLY); // 1. 获取管道文件if (fd 0){perror(open);exit(1);}string buffer; // 2. ipc过程while (true){cout Please Enter Message Line : ;getline(cin, buffer);write(fd, buffer.c_str(), buffer.size());}close(fd); // 3. 关闭return 0;
}
make之后先运行服务端再运行客户端就能实现类似微信发信息的功能客户端Ctrl C关闭 这样就实现了命名管道的通信方式建议自己写一遍代码测试一下。 4. 笔试选择题
1. 以下描述正确的有
A.进程之间可以直接通过地址访问进行相互通信
B.进程之间不可以直接通过地址访问进行相互通信
C.所有的进程间通信都是通过内核中的缓冲区实现的
D.以上都是错误的 2. 以下选项属于进程间通信的是[多选]
A.管道
B.套接字
C.内存
D.消息队列 3. 下列关于管道(Pipe)通信的叙述中正确的是()
A.一个管道可以实现双向数据传输
B.管道的容量仅受磁盘容量大小限制
C.进程对管道进行读操作和写操作都可能被阻塞
D.一个管道只能有一个读进程或一个写进程对其操作 4. 以下关于管道的描述中正确的是 [多选]
A.匿名管道可以用于任意进程间通信
B.匿名管道只能用于具有亲缘关系的进程间通信
C.在创建子进程之后也可以通过创建匿名管道实现父子进程间通信
D.必须在创建子进程之前创建匿名管道才能实现父子进程间通信 5. 以下关于管道的描述中错误的是 [多选]
A.可以通过int pipe(int pipefd[2])接口创建匿名管道其中pipefd[0]用于从管道中读取数据
B.可以通过int pipe(int pipefd[2])接口创建匿名管道其中pipefd[0]用于向管道中写入数据
C.若在所有进程中将管道的写端关闭则从管道中读取数据时会返回-1
D.管道的本质是内核中的一块缓冲区 6. 以下关于管道描述正确的有
A.命名管道可以用于同一主机上的任意进程间通信
B.向命名管道中写入的数据越多则管道文件越大
C.若以只读的方式打开命名管道时则打开操作会报错
D.命名管道可以实现双向通信
7. 以下关于管道描述正确的有
A.命名管道和匿名管道的区别在于命名管道是通过普通文件实现的
B.命名管道在磁盘空间足够的情况下可以持续写入数据
C.多个进程在通过管道通信时删除管道文件则无法继续通信
D.命名管道的本质和匿名管道的本质相同都是内核中的一块缓冲区 答案及解析 1. B A错误 进程之间具有独立性拥有自己的虚拟地址空间因此无法通过各自的虚拟地址进行通信A的地址经过B的页表映射不一定映射在什么位置 B正确 C错误 除了内核中的缓冲区之外还有文件以及网络通信的方式可以实现D 2. ABD 典型进程间通信方式管道共享内存消息队列信号量。 除此之外还有网络通信以及文件等多种方式 C选项这里的内存太过宽泛并没有特指某种技术错误。 3. C A.一个管道可以实现双向数据传输 B.管道的容量仅受磁盘容量大小限制 C.进程对管道进行读操作和写操作都可能被阻塞 D.一个管道只能有一个读进程或一个写进程对其操作 4. ABD A.匿名管道可以用于任意进程间通信 B.匿名管道只能用于具有亲缘关系的进程间通信 C.在创建子进程之后也可以通过创建匿名管道实现父子进程间通信 D.必须在创建子进程之前创建匿名管道才能实现父子进程间通信 5. BC 管道本质是内核中的一块缓冲区多个进程通过访问同一块缓冲区实现通信。使用int pipe(int pipefd[2])接口创建匿名管道pipefd[0]用于从管道读取数据pipefd[1]用于向管道写入数据。管道特性半双工通信自带同步与互斥生命周期随进程提供字节流传输服务。在同步的提现中若管道所有写段关闭则从管道中读取完所有数据后继续read会返回0不再阻塞若所有读端关闭则继续write写入会触发异常导致进程退出 根据以上管道理解分析A正确B错误C错误D正确 6. A 匿名管道只能用于具有亲缘关系的进程间通信命名管道可用于同一主机上的任意进程间通信管道的通信本质是通过内核中一块缓冲区内存时间数据传输而命名管道的管道文件只是一个标识符用于让多个进程能够访问同一块缓冲区管道是半双工通信是可以选择方向的单向通信命名管道打开特性为若以只读方式打开文件则会阻塞直到管道被以写的方式打开反之亦然 7. D A错误 管道的本质是内核中的缓冲区命名管道文件是缓冲区的标识 B错误 管道在缓冲区写满后会写阻塞跟磁盘空间并无关系 C错误 管道的生命周期随进程本质是内核中的缓冲区命名管道文件只是标识用于让多个进程找到同一块缓冲区删除后之前已经打开管道的进程依然可以通信 D正确 再就是自己实现匿名管道和命名管道。 本篇完。
下一篇零基础Linux_18(进程间通信)共享内存消息队列信号量。
