《Linux操作系统设计实践》实验二：进程通信
实验目的：
进一步了解和熟悉Linux支持的多种IPC机制，包括信号，管道，消息队列，信号量，共享内存。
实验环境：Red Hat Enterprise Linux 5
实验内容：
（1）进程间命名管道通信机制的使用
使用命名管道机制编写程序实现两个进程间的发送接收信息。
（2）进程间消息队列通信机制的使用
使用消息队列机制自行编制有一定长度的消息（1k左右）的发送和接收程序。（3）进程间共享存储区通信机制的使用
使用共享内存机制编制一个与上述（2）功能相同的程序。并比较分析与其运行的快慢。
1、进程间命名管道通信机制的使用
1.1、实验现象：
1.2、现象的分析与理解：
1.2.1、实验现象2，6解释——客户端直接写文件
如果命名管道对应的文件已经存在且类型是一般文件，客户端在打开文件时候就当作一般文件进行写操作，服务端读取新的信息并输出
1.2.2、实验现象3解释——命名管道服务端BUG
在对于已存在的管道文件来说，依据调试记录，代码的地13行要接收一个输入才能执行，导致第一次发送无法接收。
前提：管道文件已经被创建
调试记录：在服务端执行到第13被阻塞
当收到一个Good的消息时候
读取再次进入阻塞，第一次的Good消息就被清空了
1.2.3、实验现象4解释——命名管道默认使用阻塞
命名管道有自动阻塞特性，当server 打开一个有名管道准备读入时，server 进程就会被阻塞以等待其他进程（在这里是client 进程）在有名管道中写入数据。反之亦然。不过，如果需要，可以在打开一个有名管道时使用O_NONBLOCK 标志来关闭它的自动阻塞特性。这就要求使用open函数
open(FIFO_FILE, O_RDONLY| O_NONBLOCK);
命名管道默认使用阻塞的前提是命名管道文件是正常的，即必须标志为
否则命名管道读取就会发生现象3
1.2.4、实验现象5解释——命名管道文件的类型不是p
如果命名管道对应的文件已经存在且类型是一般文件，那么该文件不具有FIFO的特性，当服务器打开命名管道时候读取完内容时，内容并不消失，所以导致服务器无限读取文件内容
1.2.5、实验现象7解释——客户端直接创建一般文件
对于位创建命名管道文件的情况下，客户端会直接创建同名的一般文件进行写入，这样会导致实验现象3的出现
1.2.6、其他注意点——多组数据的接收问题
命名管道只能顺序收发消息，如果没有及时接收发送过来的消息，那么在下一次接收时会将前面的消息一并接收
调试记录：在执行第27行前发送3个消息，接收时接收并输出3个消息
对于现象10，11，12没有查阅到相关解释。
1.2.7、小结
使用命名管道必须要先创建命名管道，否则会出现读取错误，正确创建完命名管道后，后续写操作才能正常进行。要防止多个服务器进程的创建。
1.2.8、函数分析int mknod(const char * pathname, mode_t mode,dev_t dev) 1.2.8.1、S_IFIFO|0666：
1)在
#define S_IFIFO 0010000 type = named pipe
S_IFIFO 值就是为了使MODE 第5位置1，表示的类型是命名管道
后面跟着的0666表示设置的权限0不能漏，因为权限由10个位标记
1.2.8.2、在创建完命名管道用ls查看数据
说明创建的是类型为命名管道的文件
这里发现第一个标记为P就查询了一下文件类型的几种表示
1.2.8.3、文件类型：
d 目录文件。
l 符号链接(指向另一个文件,类似于瘟下的快捷方式)。
s 套接字文件。
b 块设备文件,二进制文件。
c 字符设备文件。
p 命名管道文件。
- 普通文件，或者更准确地说，不属于以上几种类型的文件。
1.2.9、测试用代码
1)#include
2)#include
3)#include
4)#include
5)#include
6)
7)#define FIFO_FILE "MYFIFO"
8)
9)int main()
10){
11)FILE *fp;
12)char readbuf[80];
13)if((fp=fopen(FIFO_FILE,"r"))==NULL)
14){
15)umask(0);
16)mknod(FIFO_FILE,S_IFIFO|0666,0);
17)}
18)else
19)fclose(fp);
20)while(1)
21){
22)if((fp=fopen(FIFO_FILE,"r"))==NULL)
23){
24)printf("open fifo failed. \n");
25)exit(1);
26)}
27)if(fgets(readbuf,80,fp)!=NULL)
28){
29)printf("Received string :%s \n", readbuf);
30)fclose(fp);
31)}
32)else
33){
34)if(ferror(fp))
35){
36)printf("read fifo failed.\n");
37)exit(1);
38)}
39)}
40)}
41)return 0;
42)}
1)// client.cpp
2)#include
3)#include
4)
5)#define FIFO_FILE "MYFIFO"
6)
7)int main(int argc, char *argv[])
8){
9)FILE *fp;
10)int i;
11)if(argc<=1)
12){
13)printf("usage: %s
14)exit(1);
15)}
16)if((fp=fopen(FIFO_FILE,"w"))==NULL)
17){
18)printf("open fifo failed. \n");
19)exit(1);
20)}
21)for(i=1;i 22){ 23)if(fputs(argv[i],fp)==EOF) 24){ 25)printf("write fifo error. \n"); 26)exit(1); 27)} 28)if(fputs(" ",fp)==EOF) 29){ 30)printf("write fifo error. \n"); 31)exit(1); 32)} 33)} 34)fclose(fp); 35)return 0; 36)} 2、进程间消息队列通信机制的使用 2.1、消息队列创建函数分析int msgget(key_t key, int msgflg) 参数key是一个键值，由ftok获得；msgflg参数是一些标志位。该调用返回与健值key相对应的消息队列描述字。 在以下两种情况下，该调用将创建一个新的消息队列： 如果没有消息队列与健值key相对应，并且msgflg中包含了IPC_CREAT标志位； key参数为IPC_PRIVATE； 参数msgflg可以为以下：IPC_CREAT、IPC_EXCL、IPC_NOWAIT或三者的或结果 具体参数含义： key: key_t ftok(const char *pathname,int proj_id) pathname:必须是存在而且可读取的文件，proj_id :表示序号，用来区别同时存在的文件 成功返回pathname 对应的键值，也就是key,错误返回－1 flag: IPC_CREAT、IPC_EXCL、IPC_NOWAIT IPC_CREAT用于创建原来不存在的的队列，IPC_CREAT|0777,设置权限位 IPC_EXCL用于测试文件是否存在，若文件已存在则返回EEXIST，（IPC_EXCL 与IPC_CREAT联合使用作为一个原子操作） IPC_NOWAIT:不阻塞 2.2、消息发送函数分析int msgsnd(int msgid，struct msgbuf *msgp,size_t msgsz,int msgflg) int msgsnd(int msgid，struct msgbuf *msgp,size_t msgsz,int msgflg) msgid:已打开的消息队列ID msgp:存储要发送的消息结构体的地址 msgsz:消息数据长度 msgflag:IPC_NOWAIT：若消息没有立即被发送则调用进程会立即返回 0：msgsnd调用阻塞直到条件满足为止 若成功则返回0，若失败则返回－1 2.3、消息接受函数分析int msgrcv(int msgid,struct msgbuf *msgp,size_t msgsz,long msgtype,int msgflag) msgid :要接受消息队列的ID msgp:存储要接收的消息结构体的地址 msgsz:消息数据长度 msgtyoe:消息类型，如果为0则接受第一个，如果>0则接受具有与函数msgtype相同的msgtype消息结构（与fifo 不同，可以从队列中接 受自己想接受的消息）如果<0则接受消息队列中第一个类型值不小 于msgtype绝对值且类型值又最小的消息 msgflag: IPC_NOWAIT、IPC_NOERROR、0 IPC_NOWAIT：若消息没有立即被接收则调用进程会立即返回 IPC_NOERROR：若返回的消息比msgsz长度字节多，则消息会截断到与msgsz长度相等。且不通知消息发送进程 0：msgsnd调用阻塞直到条件满足为止 若成功则返回0，失败则返回－1 2.4、测试用代码 代码中加入了测试时间的输出 1)#include 2)#include 3)#include 4)#include 5)#include 6)#include 7)#include 8)#define key 1 9)#define buffersize 1024*4 10) 11)int main() 12){ 13) struct SMSG 14) { 15)long mtype; 16)char mtext[buffersize]; 17) }msg ; 18) int pid; 19) int p; 20) struct timeval tpstart,tpend; 21) float timeuse; 22) gettimeofday(&tpstart,NULL); 23) while((p=fork())==-1); 24) if(p==0) 25) { 26)sleep(1); 27)pid=msgget(key,IPC_CREAT|0600); 28)msgrcv(pid,&msg,buffersize,1,0); 29)printf("receive msg is:%s\n",msg.mtext); 30)msgctl(pid,IPC_RMID,0); 31) } 32) else 33) { 34)pid=msgget(key,IPC_CREAT|0600); 35)msg.mtype=1; 36)strcpy(msg.mtext,"This is the message which the parent have sent!"); 37)while((msgsnd(pid,&msg,buffersize,0))==-1); 38)gettimeofday(&tpend,NULL); 39)timeuse=1000000*(https://www.doczj.com/doc/a816172251.html,_https://www.doczj.com/doc/a816172251.html,_sec)+ 40)https://www.doczj.com/doc/a816172251.html,_https://www.doczj.com/doc/a816172251.html,_usec; 41)timeuse/=1000000; 42)printf("Used Time:%f\n",timeuse); 43) } 44) return 0; 45)} 从结果看，在我的计算机上运行的时间在0.001100-0.001400之间 3、进程间共享存储区通信机制的使用 3.1、函数分析int shmget(key_t key, size_t size, int shmflg); key_tkey ----------------------------------------------- key标识共享内存的键值:0/IPC_PRIVATE。当key的取值为IPC_PRIVATE，则函数shmget()将创建一块新的共享内存；如果key的取值为0，而参数shmflg中设置了IPC_PRIVATE这个标志，则同样将创建一块新的共享内存。 在IPC的通信模式下，不管是使用消息队列还是共享内存，甚至是信号量，每个IPC的对象(object)都有唯一的名字，称为“键”(key)。通过“键”，进程能够识别所用的对象。“键”与IPC对象的关系就如同文件名称之于文件，通过文件名，进程能够读写文件内的数据，甚至多个进程能够共用一个文件。而在IPC的通讯模式下，通过“键”的使用也使得一个IPC对象能为多个进程所共用。 Linux系统中的所有表示SystemV中IPC对象的数据结构都包括一个ipc_perm 结构，其中包含有IPC对象的键值，该键用于查找SystemV中IPC对象的引用标识符。如果不使用“键”，进程将无法存取IPC对象，因为IPC对象并不存在于进程本身使用的内存中。 通常，都希望自己的程序能和其他的程序预先约定一个唯一的键值，但实际上并不是总可能的成行的，因为自己的程序无法为一块共享内存选择一个键值。因此，在此把key设为IPC_PRIVATE，这样，操作系统将忽略键，建立一个新的共享内存，指定一个键值，然后返回这块共享内存IPC标识符ID。而将这个新的共享内存的标识符ID告诉其他进程可以在建立共享内存后通过派生子进程，或写入文件或管道来实现。 Int size(单位字节Byte) ----------------------------------------------- size是要建立共享内存的长度。所有的内存分配操作都是以页为单位的。所以如果一段进程只申请一块只有一个字节的内存，内存也会分配整整一页(在i386机器中一页的缺省大小PACE_SIZE=4096字节)这样，新创建的共享内存的大小实际上是从size这个参数调整而来的页面大小。即如果size为1至4096，则实际申请到的共享内存大小为4K(一页)；4097到8192，则实际申请到的共享内存大小为8K(两页)，依此类推。 Int shmflg shmflg主要和一些标志有关。其中有效的包括IPC_CREAT和IPC_EXCL，它们的功能与open()的O_CREAT和O_EXCL相当。 IPC_CREAT如果共享内存不存在，则创建一个共享内存，否则打开操作。 IPC_EXCL只有在共享内存不存在的时候，新的共享内存才建立，否则就产生错误。 如果单独使用IPC_CREAT，shmget()函数要么返回一个已经存在的共享内存的操作符，要么返回一个新建的共享内存的标识符。如果将IPC_CREAT和IPC_EXCL标志一起使用，shmget()将返回一个新建的共享内存的标识符；如果该共享内存已存在，或者返回-1。IPC_EXEL标志本身并没有太大的意义，但是和IPC_CREAT标志一起使用可以用来保证所得的对象是新建的，而不是打开已有的对象。对于用户的读取和写入许可指定SHM_R和SHM_W,(SHM_R>3)和(SHM_W>3)是一组读取和写入许可，而(SHM_R>6)和(SHM_W>6)是全局读取和写入许可。 3.2、测试代码 1)#include 2)#include 3)#include 4)#include 5)#include 6)#include 7)#include 8)#include 9)#define buffersize 1024*8 10)#define Key 11)int main() 12){ 13) int p; 14) struct timeval tpstart,tpend; 15) float timeuse; 16) gettimeofday(&tpstart,NULL); 17) key_t key= ftok("/root/clc2",0); 18) while((p=fork())==-1); 19) if(p==0) 20) { 21)int pid; 22)sleep(1); 23)pid=shmget(key,buffersize,IPC_CREAT|0600); 24)char *addr; 25)addr=(char *)shmat(pid,NULL,0); 26)printf("receive msg is:%s\n",addr); 27)shmdt(addr); 28) } 29) else 30) { 31)int pid; 32)pid=shmget(key,buffersize,IPC_CREAT|0600); 33)char *addr; 34)addr=(char *)shmat(pid,NULL,0); 35)strcpy(addr," This is the message which the parent have sent!"); 36)shmdt(addr); 37)gettimeofday(&tpend,NULL); 38)timeuse=1000000*(https://www.doczj.com/doc/a816172251.html,_https://www.doczj.com/doc/a816172251.html,_sec)+ 39)https://www.doczj.com/doc/a816172251.html,_https://www.doczj.com/doc/a816172251.html,_usec; 40)timeuse/=1000000; 41)printf("Used Time:%f\n",timeuse); 42) } 43) return 0; 44)} 从结果看，在我的计算机上运行的时间在0.000450-0.000600之间速度快于消息队列 4、小结 共享内存在共享大数据文件时有用 消息队列起到信箱的作用 管道在写小数据时的及原子性得以保证 实验六：Linux进程间通信（2）（4课时） 实验目的： 理解进程通信原理；掌握进程中信号量、共享内存、消息队列相关的函数的使用。实验原理： Linux下进程通信相关函数除上次实验所用的几个还有： 信号量 信号量又称为信号灯，它是用来协调不同进程间的数据对象的，而最主要的应用是前一节的共享内存方式的进程间通信。要调用的第一个函数是semget，用以获得一个信号量ID。 int semget(key_t key, int nsems, int flag); key是IPC结构的关键字，flag将来决定是创建新的信号量集合，还是引用一个现有的信号量集合。nsems是该集合中的信号量数。如果是创建新集合（一般在服务器中），则必须指定nsems；如果是引用一个现有的信号量集合（一般在客户机中）则将nsems指定为0。 semctl函数用来对信号量进行操作。 int semctl(int semid, int semnum, int cmd, union semun arg); 不同的操作是通过cmd参数来实现的，在头文件sem.h中定义了7种不同的操作，实际编程时可以参照使用。 semop函数自动执行信号量集合上的操作数组。 int semop(int semid, struct sembuf semoparray[], size_t nops); semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。 ftok原型如下： key_t ftok( char * fname, int id ) fname就是指定的文件名(该文件必须是存在而且可以访问的)，id是子序号，虽然为int，但是只有8个比特被使用(0-255)。 当成功执行的时候，一个key_t值将会被返回，否则-1 被返回。 共享内存 共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。首先要用的函数是shmget，它获得一个共享存储标识符。 #include 进程通信实验报告 一、实验名称：进程通信 二、实验目的：掌握用邮箱方式进行进程通信的方法，并通过设计实现简单邮箱理解进程通信中的同步问题以及解决该问题的方法。 三、实验原理：邮箱机制类似于日常使用的信箱。对于用户而言使用起来比较方便，用户只需使用send （）向对方邮箱发邮件 receive （）从自己邮箱取邮件， send （）和 receive （）的内部操作用户无需关心。因为邮箱在内存中实现，其空间有大小限制。其实send （）和 receive （）的内部实现主要还是要解决生产者与消费者问题。 四、实验内容：进程通信的邮箱方式由操作系统提供形如send （）和receive （）的系统调用来支持，本实验要求学生首先查找资料了解所选用操作系统平台上用于进程通信的系统调用具体形式，然后使用该系统调用编写程序进行进程间的通信，要求程序运行结果可以直观地体现在界面上。在此基础上查找所选用操作系统平台上支持信号量机制的系统调用具体形式，运用生产者与消费者模型设计实现一个简单的信箱，该信箱需要有创建、发信、收信、撤销等函数，至少能够支持两个进程互相交换信息，比较自己实现的信箱与操作系统本身提供的信箱，分析两者之间存在的异同。 五、背景知识介绍： 1、sembuf 数据结构 struct sembuf { unsigned short int sem_num; //semaphore number short int sem_op; //semaphore operation short int sem_flg; //operation flag }; sem_num ：操作信号在信号集中的编号，第一个信号的编号是0。 进程A 进程B 信箱A 信箱B Send() Send() receive() receive() Linux进程通信 【实验程序及分析】 2. 父子进程同步 修改父进程创建子进程程序，使用exit()和wait()实现父子进程同步，其同步方式为父进程等待子进程的同步，即：子进程循环输出5次，然后父进程再循环输出5次。给出源程序代码和运行结果。 wait的函数原型是： #include 实验六：进程间通信 实验目的： 学会进程间通信方式：无名管道，有名管道，信号，消息队列， 实验要求： （一）在父进程中创建一无名管道，并创建子进程来读该管道，父进程来写该管道（二）在进程中为SIGBUS注册处理函数，并向该进程发送SIGBUS信号（三）创建一消息队列，实现向队列中存放数据和读取数据 实验器材： 软件：安装了Linux的vmware虚拟机 硬件：PC机一台 实验步骤： （一）无名管道的使用 1、编写实验代码pipe_rw.c #include //1、子进程先关闭了管道的写端 close(pipe_fd[1]); //2、让父进程先运行，这样父进程先写子进程才有内容读sleep(2); //3、读取管道的读端，并输出数据 if(read(pipe_fd[0],buf_r, r_num)<0) { printf(“read error!”); exit(-1); } printf(“%s\n”,buf_r); //4、关闭管道的读端，并退出 close(pipe_fd[1]); } else if(pid>0) //父进程执行代码 { //1、父进程先关闭了管道的读端 close(pipe_fd[0]); //2、向管道写入字符串数据 p_wbuf=&str1; write(pipe_fd[1],p_wbuf,sizof(p_wbuf)); p_wbuf=&str2; write(pipe_fd[1],p_wbuf,sizof(p_wbuf)); //3、关闭写端，并等待子进程结束后退出 close(pipe_fd[1]); } return 0; } /*********************** #include 实验一进程管理 1．实验目的： （1）加深对进程概念的理解，明确进程和程序的区别； （2）进一步认识并发执行的实质； （3）分析进程争用资源的现象，学习解决进程互斥的方法； （4）了解Linux系统中进程通信的基本原理。 2．实验预备内容 （1）阅读Linux的源码文件，加深对进程管理概念的理解； （2）阅读Linux的fork()源码文件，分析进程的创建过程。 3．实验内容 （1）进程的创建： 编写一段程序，使用系统调用fork() 创建两个子进程。当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”，子进程分别显示字符“b”和“c”。试观察记录屏幕上的显示结果，并分析原因。 源代码: #include <> #include <> #include int p1,p2; p1=fork(); ockf()函数是将文件区域用作信号量（监视锁），或控制对锁定进程的访问（强制模式记录锁定）。试图访问已锁定资源的其他进程将返回错误或进入休态，直到资源解除锁定为止。而上面三个进程，不存在要同时进入同一组共享变量的临界区域的现象，因此输出和原来相同。 （3） a) 编写一段程序，使其实现进程的软中断通信。 要求：使用系统调用fork() 创建两个子进程，再用系统调用signal() 让父进程捕捉键盘上来的中断信号（即按DEL键）；当捕捉到中断信号后，父进程用系统调用Kill() 向两个子进程发出信号，子进程捕捉到信号后分别输出下列信息后终止： Child Process 1 is killed by Parent! Child Process 2 is killed by Parent! 父进程等待两个子进程终止后，输出如下的信息后终止： Parent Process is killed! 实验一熟悉Windows2000/XP中的进程和线程 一、实验目的 1、熟悉Windows2000/XP中任务管理器的使用。 2、通过任务管理器识别操作系统中的进程和线程的相关信息。 3、掌握利用spy++.exe来察看Windows中各个任务的更详细信息。 二、实验理论基础 1、实验理论基础： （1）操作系统中的进程和线程的概念； （2）进程PCB的各项指标含意； （3）操作系统中的进程和线程的概念； （4）进程的各种控制； 三、实验内容与步骤 1、启动操作系统自带的任务管理器： 方法：直接按组合键Ctrl+Alt+Del，或者是在点击任务条上的“开始”“运行”，并输入“taskmgr.exe”。如下图所示： 2、调整任务管理器的“查看”中的相关设置，显示关于进程的以下各项信息， 并完成下表（填满即可）： 表一：统计进程的各项主要信息 3、从桌面启动办公软件“Word”，在任务管理器中找到该软件的登记，并将其结 束掉。再从任务管理器中分别找到下列程序：winlogon.exe、lsass.exe、csrss.exe、smss.exe，试着结束它们，观察到的反应是无法中止进程，原因是该程序为关键系统进程，任务管理器无法结束进程。 4、在任务管理器中找到进程“explorer.exe”，将之结束掉，并将桌面上你打开 的所有窗口最小化，看看你的计算机系统起来什么样的变化桌面所有的快捷图标消失，任务栏消失、得到的结论是这个进程用于显示桌面上的图标和开始菜单（说出explorer.exe进程的作用）。 5、运行“spy++.exe”应用软件，点击按钮“”，切换到进程显示栏上，查看进程“explorer.exe”的各项信息，并填写下表： 表二：统计线程的各项信息 进程：explorer.exe 中的各个线程 第三章 一．选择题(50题) 1.以下_B__操作系统中的技术是用来解决进程同步的。 A.管道 B.管程 C.通道 2.以下_B__不是操作系统的进程通信手段。 A.管道 B.原语 C.套接字 D.文件映射 3.如果有3个进程共享同一程序段，而且每次最多允许两个进程进入该程序段，则信号量的初值应设置为_B__。 4.设有4个进程共享一个资源，如果每次只允许一个进程使用该资源，则用P、V操作管理时信号量S的可能取值是_C__。 ,2,1,0，-1 ,1,0，-1，-2 C. 1,0，-1，-2，-3 ,3，2,1,0 5.下面有关进程的描述，是正确的__A__。 A.进程执行的相对速度不能由进程自己来控制 B.进程利用信号量的P、V 操作可以交换大量的信息 C.并发进程在访问共享资源时，不可能出现与时间有关的错误 、V操作不是原语操作 6.信号灯可以用来实现进程之间的_B__。 A.调度 B.同步与互斥 C.同步 D.互斥 7.对于两个并发进程都想进入临界区，设互斥信号量为S，若某时S=0，表示_B__。 A.没有进程进入临界区 B.有1个进程进入了临界区 C. 有2个进程进入了临界区 D. 有1个进程进入了临界区并且另一个进程正等待进入 8. 信箱通信是一种_B__方式 A.直接通信 B.间接通信 C.低级通信 D.信号量 9.以下关于临界区的说法，是正确的_C__。 A.对于临界区，最重要的是判断哪个进程先进入 B.若进程A已进入临界区，而进程B的优先级高于进程A，则进程B可以 打断进程A而自己进入临界区 C. 信号量的初值非负，在其上只能做PV操作 D.两个互斥进程在临界区内，对共享变量的操作是相同的 10. 并发是指_C__。 A.可平行执行的进程 B.可先后执行的进程 C.可同时执行的进程 D.不可中断的进程 11. 临界区是_C__。 A.一个缓冲区 B.一段数据区 C.一段程序 D.栈 12．进程在处理机上执行，它们的关系是_C__。 A.进程之间无关，系统是封闭的 B.进程之间相互依赖相互制约 C.进程之间可能有关，也可能无关 D.以上都不对 13. 在消息缓冲通信中，消息队列是一种__A__资源。 A.临界 B.共享 C.永久 D.可剥夺 14. 以下关于P、V操作的描述正确的是__D_。 A.机器指令 B. 系统调用 C.高级通信原语 D.低级通信原语 15.当对信号量进行V源语操作之后，_C__。 A.当S＜0，进程继续执行 B.当S＞0，要唤醒一个就绪进程 C. 当S＜＝ 0，要唤醒一个阻塞进程 D. 当S＜＝0，要唤醒一个就绪 16.对临界区的正确论述是__D_。 A.临界区是指进程中用于实现进程互斥的那段代码 B. 临界区是指进程中用于实现进程同步的那段代码 C. 临界区是指进程中用于实现进程通信的那段代码 D. 临界区是指进程中访问临界资源的那段代码 17. __A__不是进程之间的通信方式。 A.过程调用 B.消息传递 C.共享存储器 D.信箱通信 18. 同步是指进程之间逻辑上的__A__关系。 实验八进程通信应用 实验目的 1. 掌握命名管道的原理和应用 2. 掌握文件映射共享内存的原理 3、掌握基于进程通信的程序设计方法 实验内容 1．（1）命令行下创建有名管道myfifo，ls –l查看，分别在两个终端运行cat < myfifo 和echo hello >myfifo分析执行情况，将cat在后台运行，echo在前台运行，执行情况如何?分析FIFO的打开规则。 （2）设计两个程序，要求用命名管道FIFO，实现文本文件复制功能，即实现copy file1 file2的功能，file1是已经存在的文件，file2可以不存在，如果存在就清空原来的内容，通过建立的有名管道实现file1的内容复制到file2。 一、 FIFO 1.有名管道的创建 #include 进程间通信实验报告 班级：10网工三班学生姓名：谢昊天学号：1215134046 实验目的和要求： Linux系统的进程通信机构 (IPC) 允许在任意进程间大批量地交换数据。本实验的目的是了解和熟悉Linux支持的消息通讯机制及信息量机制。 实验内容与分析设计： （1）消息的创建，发送和接收。 ①使用系统调用msgget (), msgsnd (), msgrev (), 及msgctl () 编制一长度为1k 的消息的发送和接收程序。 ②观察上面的程序，说明控制消息队列系统调用msgctl () 在此起什么作用？ （2）共享存储区的创建、附接和段接。 使用系统调用shmget(),shmat(),sgmdt(),shmctl(),编制一个与上述功能相同的程序。（3）比较上述（1），（2）两种消息通信机制中数据传输的时间。 实验步骤与调试过程： 1.消息的创建，发送和接收： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)在SERVER端建立一个Key为75的消息队列，等待其他进程发来的消息。当遇到类型为1的消息，则作为结束信号，取消该队列，并退出SERVER 。SERVER每接收到一个消息后显示一句“(server)received”。 (3)CLIENT端使用Key为75的消息队列，先后发送类型从10到1的消息，然后退出。最后的一个消息，既是 SERVER端需要的结束信号。CLIENT每发送一条消息后显示一句“(client)sent”。 (4)父进程在 SERVER和 CLIENT均退出后结束。 2.共享存储区的创建,附接和断接： (1)先后通过fork( )两个子进程，SERVER和CLIENT进行通信。 (2)SERVER端建立一个KEY为75的共享区,并将第一个字节置为-1。作为数据空的标志.等待其他进程发来的消息.当该字节的值发生变化时,表示收到了该消息,进行处理.然后再次把它的值设为-1.如果遇到的值为0,则视为结束信号,取消该队列,并退出SERVER.SERVER 每接收到一次数据后显示”(server)received”. (3)CLIENT端建立一个为75的共享区,当共享取得第一个字节为-1时, Server端空闲,可发送请求. CLIENT 随即填入9到0.期间等待Server端再次空闲.进行完这些操作后, CLIENT退出. CLIENT每发送一次数据后显示”(client)sent”. (4)父进程在SERVER和CLIENT均退出后结束。 实验结果： 1．消息的创建，发送和接收： 由 Client 发送两条消息，然后Server接收一条消息。此后Client Server交替发送和接收消息。最后一次接收两条消息。Client 和Server 分别发送和接收了10条消息。message 的传送和控制并不保证完全同步,当一个程序不再激活状态的时候,它完全可能继续睡眠,造成上面现象。在多次send message 后才 receive message.这一点有助于理解消息转送的实现机理。 Linux进程通信实验报告 一、实验目的和要求 1.进一步了解对进程控制的系统调用方法。 2.通过进程通信设计达到了解UNIX或Linux系统中进程通信的基本原理。 二、实验内容和原理 1.实验编程，编写程序实现进程的管道通信(设定程序名为pipe.c)。使 用系统调用pipe()建立一条管道线。而父进程从则从管道中读出来自 于两个子进程的信息，显示在屏幕上。要求父进程先接受子进程P1 发来的消息，然后再接受子进程P2发来的消息。 2.可选实验，编制一段程序，使其实现进程的软中断通信(设定程序名为 softint.c)。使用系统调用fork()创建两个子进程，再用系统调用 signal()让父进程捕捉键盘上来的中断信号(即按Del键)，当父进程 接受这两个软中断的其中一个后，父进程用系统调用kill()向两个子 进程分别发送整数值为16和17的软中断信号，子进程获得对应软中 断信号后分别输出相应信息后终止。 三、实验环境 一台安装了Red Hat Linux 9操作系统的计算机。 四、实验操作方法和步骤 进入Linux操作系统，利用vi编辑器将程序源代码输入并保存好，然后 打开终端对程序进行编译运行。 五、实验中遇到的问题及解决 六、实验结果及分析 基本实验 可选实验 七、源代码 Pipe.c #include"stdio.h" #include"unistd.h" main(){ int i,j,fd[2]; char S[100]; pipe(fd); if(i=fork==0){ sprintf(S,"child process 1 is sending a message \n"); write(fd[1],S,50); sleep(3); return; } if(j=fork()==0){ sprintf(S,"child process 2 is sending a message \n"); write(fd[1],S,50); sleep(3); return; 第3章进程同步与通信练习题 (一)单项选择题 1.临界区是指( )。 A.并发进程中用于实现进程互斥的程序段 B．并发进程中用于实现进程同步的程序段 C．并发进程中用户实现进程通信的程序段 D．并发进程中与共享变量有关的程序段 2．相关临界区是指( )。 A.一个独占资源 B．并发进程中与共享变量有关的程序段 c．一个共享资源 D．并发进程中涉及相同变量的那些程序段 3．管理若干进程共享某一资源的相关临界区应满足三个要求,其中( )不考虑。 A一个进程可以抢占己分配给另一进程的资源 B．任何进程不应该无限地逗留在它的临界区中c．一次最多让一个进程在临界区执行 D．不能强迫一个进程无限地等待进入它的临界区4、( )是只能由P和v操作所改变的整型变量。 A共享变量 B．锁 c整型信号量 D．记录型信号量 5．对于整型信号量，在执行一次P操作时，信号量的值应( )。 A．不变 B．加1 C减1 D．减指定数值 6．在执行v操作时，当信号量的值( )时，应释放一个等待该信号量的进程。 A>0 B.<0 c.>=0 D.<=0 7.Pv操作必须在屏蔽中断下执行，这种不可变中断的过程称为( )。 A初始化程序 B．原语 c．子程序 D控制模块 8．进程间的互斥与同步分别表示了各进程间的( )。 A．竞争与协作 B．相互独立与相互制约 c．不同状态 D．动态性与并发性 9并发进程在访问共享资源时的基本关系为( )。 A．相互独立与有交往的 B．互斥与同步 c并行执行与资源共享 D信息传递与信息缓冲 10．在进程通信中，( )常用信件交换信息。 A．低级通信 B．高级通信 c．消息通信 D．管道通信 11．在间接通信时，用send(N，M)原语发送信件，其中N表示( )。 A．发送信件的进程名 B．接收信件的进程名 C信箱名 D．信件内容 12．下列对线程的描述中，( )是错误的。 A不同的线程可执行相同的程序 B．线程是资源分配单位 c．线程是调度和执行单位 D．同一 进程中的线程可共享该进程的主存空间 13．实现进程互斥时，用( )对应，对同一个信号量调用Pv操作实现互斥。 A．一个信号量与一个临界区 B．一个信号量与—个相关临界区 c．一个信号量与一组相关临界 区 D一个信号量与一个消息 14．实现进程同步时，每一个消息与一个信号量对应，进程( )可把不同的消息发送出去。 A．在同一信号量上调用P操作 B在不同信号量上调用P操作 c．在同一信号量上调用v操作D．在不同信号量上调用v操作 (二)填空题 1．目前使用的计算机的基本特点是处理器______执行指令。 2．进程的______是指进程在顺序处理器上的执行是按顺序进行的。 3．当一个进程独占处理器顺序执行时，具有______和______两个特性。 4．进程的封闭性是指进程的执行结果只取决于______，不受外界影响。 5 进程的可再现性是指当进程再次重复执行时，必定获得______的结果。 6．一个进程的工作在没有全部完成之前,另一个进程就可以开始工作，则称这些进程为______. 操作系统实验报告 实验三、进程通信（一） ——管道及共享内存 一、实验目的 熟悉和掌握LINUX系统的管道通信和共享内存通信。 二、实验内容 (一)、管道通信 1、实验原理： 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统。 数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。 利用系统调用pipe()可创建一个简单的管道。 int fd[2]； pipe(fd)； 调用成功，fd[0]存放供读进程使用的文件描述符（管道出口），fd[1]存放供写程使用的文件描述符（管道入口）。 一个进程在由pipe()创建管道后，一般再fork()一个子进程，然后通过管道实现父子进程间的通信，子进程将从父进程那里继承所有打开的文件描述符。则父子两个进程都能访问组成管道的两个文件描述符，这样子进程可以向父进程发送消息（或者相反）。 发送进程利用文件系统的系统调用write(fd[1],buf,size)，把buf中size个字符送入fd[1]，接收进程利用read(fd[0],buf,size)，把从fd[0]读出的size个字符置入buf中。这样管道按FIFO（先进先出）方式传送信息。 2、实验内容： #include if (x==0) { close(fd[0]); printf("Child Process!\n"); strcpy(buf,"This is an example\n"); write(fd[1],buf,30); exit(0); } else{ close(fd[1]); printf("Parent Process!\n"); read(fd[0],s,30); printf("%s\n",s); printf("x value in Parent Process:%d!\n",x); } } （1）阅读上述父子进程利用管道进行通信的例子，写出程序的运行结果并分析。 程序运行x=fork()后，创建里一个子进程，在子进程里x的返回值为0，在父进程里x的返回值为7684，则子进程会执行if语句里的代码段，先关闭了管道的读入端，再在屏幕上输出“Child Process!”，然后将“This is an example\n”存入buf数组中，通过调用write()函数将buf数组的内容从管道的写入端写入，而父进程会执行else语句里的代码段，先关闭了管道的写入端，再在屏幕上输出“Parent Process!”，然后通过调用read ()函数将buf数组的内容从管道的读入端读入冰存储在s数组里，接着通过printf()函数将s数组里的内容输出到屏幕上，最后在屏幕上输出父进程中x的值。 （2）编写程序：父进程利用管道将一字符串交给子进程处理。子进程读字符串，将里面的字符反向后再交给父进程，父进程最后读取并打印反向的字符串。 #include 实验三进程的同步 一、实验目的 1、了解进程同步和互斥的概念及实现方法； 2、更深一步的了解fork()的系统调用方式。 二、实验内容 1、预习操作系统进程同步的概念及实现方法。 2、编写一段源程序，用系统调用fork()创建两个子进程，当此程序运行时，在系统中有一个父进程和两个子进程活动。让每一个进程在屏幕上显示一个字符：父进程显示字符“a”；子进程分别显示字符“b”和字符“c”。程序的输出是什么？分析原因。 3、阅读模拟火车站售票系统和实现进程的管道通信源代码，查阅有关进程创建、进程互斥、进程同步的系统功能调用或API，简要解释例程中用到的系统功能或API的用法，并编辑、编译、运行程序，记录程序的运行结果，尝试给出合理的解释。 4、（选做）修改问题2的代码，使得父子按顺序显示字符“a”；“b”、“c”编辑、编译、运行。记录程序运行结果。 三、设计思想 1、程序框架 （1）创建两个子进程：（2）售票系统： （3）管道通信： 先创建子进程，然后对内容加锁，将输出语句存入缓存，并让子进程自己进入睡眠，等待别的进程将其唤醒，最后解锁；第二个子进程也执行这样的过程。父进程等待子进程后读内容并输出。 （4）修改程序（1）：在子进程的输出语句前加上sleep()语句，即等待父进程执行完以后再输出。 2、用到的文件系统调用函数 （1）创建两个子进程：fork() （2）售票系统：DWORD WINAPI Fun1Proc(LPVOID lpPartameter); CreateThread(NULL,0,Fun1Proc,NULL,0,NULL); CloseHandle(hThread1); (HANDLE)CreateMutex(NULL,FALSE,NULL); Sleep(4000)（sleep调用进程进入睡眠状态(封锁), 直到被唤醒）; WaitForSingleObject(hMutex,INFINITE); ReleaseMutex(hMutex); （3）管道通信：pipe(fd)，fd: int fd[2]，其中: fd[0] 、fd[1]文件描述符（读、写）; lockf( fd，function，byte)（fd: 文件描述符；function: 1: 锁定 0:解锁；byte: 锁定的字节数，0: 从当前位置到文件尾）; write(fd，buf，byte)、read(fd，buf，byte) （fd: 文件描述符；buf : 信息传送的源（目标）地址；byte: 传送的字节数）; sleep(5); exit(0); read(fd[0]，s，50) （4）修改程序（1）：fork(); sleep(); 四、调试过程 1、测试数据设计 （1）创建两个子进程： 实验三进程通信(二) 实验目的： 1、理解进程通信原理和基本技术 2、了解linux系统进程间通信机构（IPC）； 3、理解linux关于共享内存的概念； 4、掌握linux支持进程间共享内存的系统调用； 5、巩固进程同步概念。 实验内容： （一）闹钟。用c语言编程，实现进程间通过信号进行通信。 用fork（）创建两个进程，子进程在等待5秒后用系统调用kill（）向父进程发送SIGALRM 信号，父进程用系统调用signal（）捕捉SIGALRM信号。参考程序如下： #include 武汉工程大学计算机科学与工程学院 《操作系统》实验报告[Ⅰ] 一、实验目的 创建进程，实现进程消息通信和共享内存通信，了解进程的创建、退出和获取进程信。了解什么是映像文件、管道通信及其作用，掌握通过内存映像文件和管道技术实现进程通信。 二、实验内容 本例用三种方法实现进程通信，仅用于示例目的，没有进行功能优化。 1、创建进程A和B后，在进程A中输入一些字符，点“利用 SendMessage发送消息”按钮可将消息发到进程B。 2、在进程A中输入一些字符，点“写数据到内存映像文件”按钮， 然后在进程B中点“从内存映像文件读数据”按钮可收到消息。其中在点“写数据到内存映像文件”时，要求创建映像文件，B进程在印象文件中读取数据。 3、先在进程B中点“创建管道并接收数据”按钮，然后在进程A 中输入一些字符，点“写数据到管道文件”按钮可将消息发到进程B。管道是连接读/写进程使他们进行通信的一个共享文件，目的是更好地实现进程间的通信。 三、实验思想 这次试验最主要的内容和核心思想就是学会创建进程并实现进程间的简单通信、创建映像文件和创建管道文件来通信，后两者是实现进程通信的高级通信机制中的两种。. 创建一个程序A和程序B，其中程序A和B各有一个主窗体，A主窗体上要求可以实现创建进程B（即调用函数B）、结束进程B、关闭进程A、向进程B发送数据、创建映像文件、创建管道文件等功能，进程B要求有从映像文件读取数据、创建管道并接收数据、结束进程B功能。最终让A、B进程相互通信。 四、设计分析： 首先设得设计A、B两个程序的操作界面，然后编写各个功能模块。对于A 程序窗体，在“利用SendMessage发送消息”按钮的消息响应函数中，主要是利用Windows API函数CWnd::FindWindow来找到接收消息的窗体，即进程B，找到进程B后，利用这个函数返回的窗体指针的SendMessage函数来发送消息。在“写数据到内存印象文件”按钮的消息响应函数中，主要是利用函数CreateFileMapping来创建一个印象文件，这个函数返回的是这个印象文件的句柄，然后将这个句柄和要发送的消息字符串传递到函数sprintf中，就可以所要发送的消息写入印象文件，在B程序窗体中有个“从内存印象文件读数据”按钮，在这个按钮的消息响应函数中读取父进程所创建的印象文件中的数据就可以实现通信了。在B程序窗体按钮“写数据到管道文件”的消息响应函数中，不能直接将要发送的消息发送到管道文件，因为管道必须先由子进程通过函数CreateNamedPipe创建，只有待子进程创建好管道后父进程才能根据管道创建管道文件，将消息写入管道文件并及时发送给子进程。而且这个管道只能使用一次，即每次发送完消息后那个管道不能在使用了，必须再由子进程创建一个管道，A 进程才能再次创建管道文件并向其中写入消息。这个程序也不一定要MFC实现，还可以用其他的技术和语言实现，比如说Java、VB等，外表构架可以不一样，但核心技术都是一样的，只是不同的调用形式和调用方法，比如说在VB中，实现进程间的一般通信就是使用动态数据交换ＤＤＥ，实现起来就比较简单，但是要创建映像文件和管道文件就比较繁琐，可以根据不同的需求采用不同的语言。 五、程序部分源代码： 1.“利用SendMessage发送消息”按钮中的主要代码 //找到接收消息的窗口(窗口名为Receiver) CString str="进程B"; CWnd *pWnd=CWnd::FindWindow(NULL,str); if(pWnd) { COPYDATASTRUCT buf; char * s=new char[m_Msg1.GetLength()]; //m_Msg1为CString类型的变量 s=m_Msg1.GetBuffer(0); 操作系统课程实验二 年级2012 级 专业计算机科学与技术（应用型）指导教师黄玲 学号 姓名 实验二、Linux进程同步与通信 一、关键问题 1、实验目的 理解进程的高级通信；理解通过信号量实现进程的同步。 2、实验环境 Ubuntu 8.0或者以上，Eclipse集成开发环境 3、实验内容 3.1 观察Linux进程通信 下面代码实现两个进程之间通过共享内存通信。 3.2 Linux进程同步 实验要求：一个生产者向一个缓冲区发消息，每当发出一个消息后，要等待三个消费者都接收这条消息后，生产者才能发送新消息。用信号量和P、V操作，写出他们同步工作的程序。（提示：可以把缓冲区看作是三个缓冲块组成的缓冲区，生产者等到这三个缓冲块为空时，才发送新消息到这个缓冲区。每个消费者从一个缓冲块取走数据。） 二、设计修改思路 这是一个典型的生产者消费者问题可以基于信号灯解决，由于有3个消费者，一个生产者，共用同一个缓冲区，所以我们需要设置4个信号灯来控制4个进程的互斥。一个生产者进程不断向修改变量（写入10次），三个消费者进程从缓冲区中读取数据。创建了empty、full1、full2、full3四个信号量，供进程间同步访问临界区，同时建立两个虚存区：a用于生产者、消费者之间的共享数据，get 记录当前生产者进程和消费者进程的读写次数。 实现的算法如下： 生产者进程 { p(empty); p(empty); p(empty); 发送消息 v(full1); v(full2); v(full3); } 消费者A进程 { p(full1); 接受消息 v(empty); } 消费者B、C进程和A进程类似 实验五进程间通信实验 一、实验目的 1、了解什么是信号。 2、熟悉LINUX系统中进程之间软中断通信的基本原理。 3、了解什么是管道 4、熟悉UNIX/LINUX支持的管道通信方式 二、实验内容 1、编写一段程序，使用系统调用fork( )创建两个子进程，再用系统调用signal( )让父进程捕捉键盘上来的中断信号（即按ctrl+c键），当捕捉到中断信号后，父进程用系统调用kill( )向两个子进程发出信号，子进程捕捉到信号后，分别输出下列信息后终止：Child process 1 is killed by parent! Child process 2 is killed by parent! 父进程等待两个子进程终止后，输出以下信息后终止： Parent process is killed! <参考程序> #includeLinux进程间通信(2)实验报告
线程实现邮箱通信-实验报告
实验四父子进程通信
Linux系统编程实验六进程间通信
进程管理实验报告文档
实验一 和实验二
进程同步与通信作业习题与答案
实验八 进程通信应用
进程间通信实验报告
Linux进程通信实验报告
第3章 进程同步与通信 练习题答案
实验三 进程通信(一)
进程同步实验报告
实验三 进程通信doc(DOC)
操作系统进程创建及通信实验报告
操作系统实验Linux进程同步与通信操作系统二
实验5 进程间通信实验
相关主题
文本预览