实验二,进程通信,管道共享内存

实验二,进程通信,管道共享内存
实验二,进程通信,管道共享内存

操作系统实验报告

实验二:进程通信(一)——管道及共享内存

一、实验目的

?了解进程之中相互通信的方式

?加深对管道通信的了解

?了解共享内存通信的程序设计方法

?了解和熟悉Linux支持的共享存储区机制

二、实验内容和步骤

任务一、

(1)阅读以上父子进程利用管道进行通信的例子(例1),写出程序的运行结果并分析。

(2)编写程序:父进程利用管道将一字符串交给子进程处理。子进程读字符串,将里面的字符反向后再交给父进程,父进程最后读取并打印反向的字符串

任务二、

1)阅读例2的程序,运行一次该程序,然后用ipcs命令查看系统中共享存储区的情况,再次执行该程序,再用ipcs命令查看系统中共享内存的情况,对两次的结果进行比较,并分析原因。最

后用ipcrm命令删除自己建立的共享存储区。(有关ipcs和ipcrm介绍见后面一页)

(2)每个同学登陆两个窗口,先在一个窗口中运行例3程序1(或者只登陆一个窗口,先在该窗口中以后台方式运行程序1),然后在另一个窗口中运行例3程序2,观察程序的运行结果并分析。

运行结束后可以用ctrl+c结束程序1的运行。

(3)编写程序:使用系统调用shmget(),shmat(),shmdt(),shmctl(),编制程序。要求在父进程中生成一个30字节长的私有共享内存段。接下来,设置一个指向共享内存段的字符指针,将一串大写字母写入到该指针指向的存贮区。调用fork()生成子进程,让子进程共享内存段中的内容。接着,将大写字母改成小写,子进显示程修改共享内存中的内容。之后,子进程将脱接共享内存段并退出。父进程在睡眠5秒后,在此显示共享内存段中的内容(此时已经是小写字母)。

三、代码及运行结果分析

1.任务1(1)

①代码:

#include

#include

#include

#include

#include

#include

int main()

{

int x,fd[2];

char buf[30],s[30];

pipe(fd);

while((x=fork())==-1);

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);

}

}

②截图:

③结果和分析:

创建一个管道,调用fork()函数产生两个进程,我的系统优先先执行父进程,比较疑惑,既然这样,管道中并没有数据是如何得出最后结果的,后来百度了一下解释说是因为管道本身是一种同步机

制,并且printf执行的时间要比其他程序时间长得多,才会这样。然后执行子程序,将数据写入管道,然后父程序打印出来

2. 任务1(2)

①代码:

#include

#include

#include

#include

#include

#include

void fanzhuan(char *s){

char *p=s+strlen(s)-1;

char temp;

while(s

temp=*p;

*p--=*s;

*s++=temp;

}

}

int main()

{

int i,x,fd[2];

char buf[20],s[20],m[20];

strcpy(buf,"This is an example\n");

pipe(fd);

write(fd[1],buf,20);

while((x=fork())==-1);

if(x==0){

printf("Child Process!\n");

read(fd[0],s,20);

//printf("%s\n",s);

fanzhuan(s);

write(fd[1],s,20);

exit(0);

}

else{

wait(NULL);

close(fd[1]);

printf("Parent Process!\n");

read(fd[0],m,20);

printf("%s\n",m);

}

}

②截图:

3. 任务2(1)

①代码:

#include

#include

#include

#include

#include

int main(){

key_t key=105;

int shmid_1,shmid_2;

if((shmid_1=shmget(key,1000,0644|IPC_CREAT))==-1){ perror("shmget shmid_1");

exit(1);

}

printf("First shared memory identifier is %d\n",shmid_1);

if((shmid_2=shmget(IPC_PRIVATE,20,0644))==-1){ perror("shmget shmid_2");

exit(2);

}

printf("Second shared memory identifier is %d\n",shmid_2);

exit(0);

}

②截图:

③结果和分析:

两次运行结束后,第二个共享标识符不一样,然后在每一次的ipcs 查看共享存储区的时候,最后一行也是不一样的。原因是分配了两次,

然后第一次有key值,第二次是没有的。

4. 任务2(2)

①代码:

程序1:

#include

#include

#include

#include

#include

#include

#include

#define SHMKEY 105

#define K 1024

int shmid;

int main(){

int i,*pint;

char *addr;

extern void* shmat();

extern cleanup();

for(i=0;i<20;i++)

signal(i,cleanup);

shmid=shmget(SHMKEY,16*K,0777|IPC_CREAT);

addr=shmat(shmid,0,0);

printf("addr 0x%x\n",addr);

pint=(int *)addr;

for(i=0;i<256;i++)

*pint++=i;

pause();

}

cleanup(){

shmctl(shmid,IPC_RMID,0);

exit(0);

}

程序2:

#include

#include

#include

#include

#include

Linux进程间通信(2)实验报告

实验六: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 #include #include int shmget(key_t key, int size, int flag); 当共享内存创建后,其余进程可以调用shmat()将其连接到自身的地址空间中。 void *shmat(int shmid, void *addr, int flag); shmid为shmget函数返回的共享存储标识符,addr和flag参数决定了以什么方式来确定连接的地址,函数的返回值即是该进程数据段所连接的实际地

共享内存+互斥量实现linux进程间通信

共享内存+互斥量实现linux进程间通信 一、共享内存简介 共享内存是进程间通信中高效方便的方式之一。共享内存允许两个或更多进程访问同一块内存,就如同malloc() 函数向不同进程返回了指向同一个物理内存区域的指针,两个进程可以对一块共享内存进行读写。 共享内存并未提供进程同步机制,使用共享内存完成进程间通信时,需要借助互斥量或者信号量来完成进程的同步。这里说一下互斥量与信号量的区别。互斥量用于线程的互斥,信号量用于线程的同步,这是互斥量与信号量的本质区别,其次信号量实现互斥量的功能。 本文结合个人实际项目需求,采用互斥量实现进程间访问共享内存的互斥,即同一时刻只能允许一个进程对共享内存进行写操作。 二、使用系统调用完成共享内存的申请、连接、分离和删除 共享内存函数由shmget、shmat、shmdt、shmctl四个函数组成。使用时需要包含#include 、#include 、#include 和。 1.共享内存的申请 使用shmget()完成共享内存的申请,函数原型如下: int shmget(key_t key, size_t size, int shmflg); key:共享内存的标识符,大于0的32位整数。若是父子关系的进程间通信,这个标识符用IPC_PRIVATE,若进程没有关系,可自行定义。 size:共享内存大小,单位Byte。 shmflg:共享内存的模式(mode),包括三部分,第一部分是:无指定标示符的共享内存是否创建,由0(只获取)或IPC_CREAT(未创建则新建)决定。第二部分:IPC_EXCL(若已创建,则报错)。第三部分:权限标识,由八进制表示,如0640,第一个0是八进制数标识,第一个6(4+2)表示拥有者的权限读和写,第二个4表示同组权限写,第3个0表示他人的权限。这三部分由算数或运算符|拼接组成shmflg,如IPC_CREAT|0640。 成功时返回共享内存的ID,失败时返回-1。 2.共享内存的连接 使用shmat()函数将已经申请好的共享连接到当前进程的地址空间,函数原型如下: void *shmat(int shmid, const void *shmaddr, int shmflg); shmid:共享内存标识符。 shmaddr:指定进程使用共享内存的起始地址,直接指定为NULL让内核自己决定一个合适的地址位置。 shmflg:SHM_RDONLY为只读模式,其他为读写模式,通常设置为NULL。 成功时,这个函数返回共享内存的起始地址。失败时返回-1。 3.共享内存的分离 使用sdmdt()函数将已连接的共享内存与进程分离,功能与shmat()相反,函数原型如下:int shmdt(const void *shmaddr); shmaddr:连接的共享内存的起始地址。成功时返回0。失败时返回-1。 4.共享内存的删除 shmctl() 控制对这块共享内存的使用,包括删除。函数原型如下: int shmctl(int shmid, int command, struct shmid_ds *buf); shmid:共享内存的ID。 command:是控制命令,IPC_STAT(获取共享内存的状态)、IPC_SET(改变共享内存的状态)IPC_RMID (删除共享内存)。

实验二(1)进程同步

实验二(2)进程同步 一、实验目的 1、生产者-消费者问题是很经典很具有代表性的进程同步问题,计算机中的很多同步问题都可抽象为生产者-消费者问题,通过本实验的练习,希望能加深学生对进程同步问题的认识与理解。 2、熟悉VC的使用,培养和提高学生的分析问题、解决问题的能力。 二、实验内容及其要求 1.实验内容 以生产者/消费者模型为依据,创建一个控制台进程,在该进程中创建n个线程模拟生产者和消费者,实现进程(线程)的同步与互斥。 2.实验要求 学习并理解生产者/消费者模型及其同步/互斥规则;设计程序,实现生产者/消费者进程(线程)的同步与互斥; 三、实验算法分析 1、实验程序的结构图(流程图); 2、数据结构及信号量定义的说明; (1) CreateThread ●功能——创建一个在调用进程的地址空间中执行的线程 ●格式 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize,

LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParamiter, DWORD dwCreationFlags, Lpdword lpThread ); ●参数说明 lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。dwStackSize——定义原始堆栈大小。 lpStartAddress——指向使用LPTHRAED_START_ROUTINE类型定义的函数。 lpParamiter——定义一个给进程传递参数的指针。 dwCreationFlags——定义控制线程创建的附加标志。 lpThread——保存线程标志符(32位) (2) CreateMutex ●功能——创建一个命名或匿名的互斥量对象 ●格式 HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName); bInitialOwner——指示当前线程是否马上拥有该互斥量(即马 ●参数说明 lpMutexAttributes——必须取值NULL。上加锁)。 lpName——互斥量名称。 (3) CreateSemaphore ●功能——创建一个命名或匿名的信号量对象 ●格式 HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCTSTR lpName ); ●参数说明 lpSemaphoreAttributes——必须取值NULL。

实验三 进程通信doc(DOC)

实验三进程通信(二) 实验目的: 1、理解进程通信原理和基本技术 2、了解linux系统进程间通信机构(IPC); 3、理解linux关于共享内存的概念; 4、掌握linux支持进程间共享内存的系统调用; 5、巩固进程同步概念。 实验内容: (一)闹钟。用c语言编程,实现进程间通过信号进行通信。 用fork()创建两个进程,子进程在等待5秒后用系统调用kill()向父进程发送SIGALRM 信号,父进程用系统调用signal()捕捉SIGALRM信号。参考程序如下: #include #include #include static int alarm_fired = 0; //闹钟未设置 //模拟闹钟 void ding(int sig) { alarm_fired = 1; //设置闹钟 } int main() { int pid; printf("alarm application starting\n"); if((pid = fork( )) == 0) { //子进程5秒后发送信号SIGALRM给父进程 sleep(5); kill(getppid(), SIGALRM); //exit(0); return 0; } //父进程安排好捕捉到SIGALRM信号后执行ding函数 printf("waiting for alarm to go off\n"); (void) signal(SIGALRM, ding); pause(); //挂起父进程,直到有一个信号出现 if (alarm_fired) printf("Ding!\n"); printf("done\n");

Linux系统编程实验六进程间通信

实验六:进程间通信 实验目的: 学会进程间通信方式:无名管道,有名管道,信号,消息队列, 实验要求: (一)在父进程中创建一无名管道,并创建子进程来读该管道,父进程来写该管道(二)在进程中为SIGBUS注册处理函数,并向该进程发送SIGBUS信号(三)创建一消息队列,实现向队列中存放数据和读取数据 实验器材: 软件:安装了Linux的vmware虚拟机 硬件:PC机一台 实验步骤: (一)无名管道的使用 1、编写实验代码pipe_rw.c #include #include #include #include #include #include int main() { int pipe_fd[2];//管道返回读写文件描述符 pid_t pid; char buf_r[100]; char* p_wbuf; int r_num; memset(buf_r,0,sizeof(buf_r));//将buf_r初始化 char str1[]=”parent write1 “holle””; char str2[]=”parent write2 “pipe”\n”; r_num=30; /*创建管道*/ if(pipe(pipe_fd)<0) { printf("pipe create error\n"); return -1; } /*创建子进程*/ if((pid=fork())==0) //子进程执行代码 {

//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 #include #include #include #include #include int main() { int pipe_fd[2];//管道返回读写文件描述符 pid_t pid; char buf_r[100]; char* p_wbuf; int r_num;

进程间通信实验报告

进程间通信实验报告 班级: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、实验原理: 管道是半双工的,数据只能向一个方向流动;需要双方通信时,需要建立起两个管道;单独构成一种独立的文件系统:管道对于管道两端的进程而言,就是一个文件,但它不是普通的文件,它不属于某种文件系统,而是自立门户,单独构成一种文件系统。 数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。 利用系统调用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 main() { int x,fd[2]; char buf[30],s[30]; pipe(fd); while ((x=fork())==-1);

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 main() { int i,x,fd[2]; char buf[20],s[20],cpy[20],m[20]; strcpy(buf,"This is an example\n"); pipe(fd); write(fd[1],buf,20);

linux下共享内存

Linux下共享内存 SUNNY.MAN 共享内存允许两个或多个进程进程共享同一块内存(这块内存会映射到各个进程自己独立的地址空间) 从而使得这些进程可以相互通信,进程退出时会自动和已经挂接的共享内存区段分离,但是仍建议当进程不再使用共享区段时调用shmdt来卸载区段。注意,当一个进程分支出父进程和子进程时,父进程先前创建的所有共享内存区段都会被子进程继承。如果区段已经做了删除标记(在前面以IPC_RMID指令调用shmctl),而当前挂接数已经变为0,这个区段就会被移除。Linux中通过API函数shmget创建的共享内存一般都是在程序中使用shmctl来释放的,但是有时为了调试程序,开发人员可能通过Ctrl + C等方式发送中断信号来结束程序,此时程序申请的共享内存就不能得到释放,当然如果程序没有改动的话,重新运行程序时仍然会使用上次申请的共享内存,但是如果我们修改了程序,由于共享内存的大小不一致等原因会导致程序申请共享内存错误。因此,我们总是希望每次结束时就能释放掉申请的共享内存。 有两种方法可以用来释放共享内存: 第一种:如果总是通过Crtl+C来结束的话,可以做一个信号处理器,当接收到这个信号的时候,先释放共享内存,然后退出程序。 第二种:不管你以什么方式结束程序,如果共享内存还是得不到释放,那么可以通过linux命令ipcrm shm shmid来释放,在使用该命令之前可以通过ipcs -m命令来查看共享内存。 共享内存查看 使用ipcs命令,不加如何参数时,会把共享内存、信号量、消息队列的信息都

打印出来,如果只想显示共享内存信息,使用如下命令: [root@localhost ~]# ipcs –m 同样共享内存的大小也可以用ipcs –lm来查看它的上限下限。 shmget( ) 创建一个新的共享内存区段 取得一个共享内存区段的描述符 shmctl( ) 取得一个共享内存区段的信息 为一个共享内存区段设置特定的信息 移除一个共享内存区段 shmat( ) 挂接一个共享内存区段 shmdt( ) 于一个共享内存区段的分离 同样共享内存的大小也可以用ipcs –lm来查看它的上限下限。我们主要也是关心三个变量,一个是一共可以建立多少个共享内存段,每个段都大可以多少,一共有多少内存可以共享。 使用下面的命令查看共享内存的大小: max number of segments = 4096//总共可以有多少个段 max seg size (kbytes) = 4194303//一个段可以多大 max total shared memory (kbytes) = 1073741824//所有可以共享的内存大小 min seg size (bytes) =1 # cat /proc/sys/kernel/shmmax 修改共享内存大小: 临时修改:在root用户下执行

os实验二 进程同步

实验二:进程同步 一.实验目的 (1)掌握基本的同步算法,理解生产者消费者模型。 (2)学习使用Windows XP中基本的同步对象,掌握相关API的使用方法。 (3)了解Windows XP中多线程的并发执行机制,实现进程的同步与互斥。 二.实验属性 该实验为设计性实验。 三.实验仪器设备及器材 普通PC386以上微机 四.实验要求 本实验要求2学时完成。 本实验要求完成如下任务: (1)以生产者/消费者模型为依据,在Windows XP环境下创建一个控制台进程,在该进程中创建n个线程模拟生产者和消费者,实现进程(线程)的同步与互斥。 学习并理解生产者/消费者模型及其同步/互斥规则; 学习了解Windows同步对象及其特性; 熟悉实验环境,掌握相关API的使用方法; 设计程序,实现生产者/消费者进程(线程)的同步与互斥。 (2)扩展任务2选1: 1>利用信号量机制,写出不会发生死锁的解决哲学家进程(线程)。 最多允许4个同时进餐;奇:先左后右偶:先右后左。 2>利用信号量机制,写出不会发生死锁的读者写者进程(线程)。五:实验内容: 利用至多同时允许4位哲学家同时去拿左边筷子的方法解决进餐死锁的问题。 实验详细设计:流程图:

程序首先创建一个线程参数结构体 struct ThreadInfo { int serial; double delay; }; 设置最多同时去拿筷子的人数#define MAX_BUFFER_NUM 4 设置一个信号量数组用来表示五位哲学家的左右边的筷子HANDLE chopstick [5]; 设置同时去拿筷子的人数的信号量HANDLE People; 设置一个互斥信号量HANDLE h_mutex; 在main()函数中,首先创建信号量: for (int i=0;i<5;i++) { chopstick[i]=CreateSemaphore(NULL,n_Buffer_or_Critical,n_Buffer_or_Criti cal,"chopstick"+i); } People=CreateSemaphore(NULL,MAX_BUFFER_NUM,MAX_BUFFER _NUM,"People");

李建伟版实用操作系统第二版最新习题 3 进程同步与通信

李建伟版实用操作系统第二版最新习题 3 进程同步与通信 一、选择题 题号1 2 3 4 5 6 7 8 9 10 答案A D D C B C A B A A 题号11 12 答案D C 二、综合题 1、答:临界资源也称独占资源、互斥资源,它是指某段时间内只充许一个进程使用的资源。比如打印机等硬件资源,以及只能互斥使用的变量、表格、队列等软件资源。各个进程中访问临界资源的、必须互斥执行的程序代码段称为临界区,各进程中访问同一临界资源的程序代码段必须互斥执行。 为防止两个进程同时进入临界区,可采用软件解决方法或同步机构来协调它们。但是,不论是软件算法还是同步机构都应遵循下述准则: ①空闲让进。②忙则等待。③有限等待。④让权等待。 2、答:忙等待意味着一个进程正在等待满足一个没有闲置处理器的严格循环的条件。因为只有一个CPU 为多个进程服务,因此这种等待浪费了CPU 的时钟。 其他类型的等待:与忙等待需要占用处理器不同,另外一种等待则允许放弃处理器。如进程阻塞自己并且等待在合适的时间被唤醒。忙等可以采用更为有效的办法来避免。例如:执行请求(类似于中断)机制以及PV 信号量机制,均可避免“忙等待”现象的发生。 3、答: 在生产者—消费者问题中,Producer 进程中P(empty)和P(mutex)互换先后次序。先 执行P(mutex),假设成功,生产者进程获得对缓冲区的访问权,但如果此时缓冲池已满,没有空缓冲区可供其使用,后续的P(empty)原语没有通过,Producer 阻塞在信号量empty 上,而此时mutex 已被改为0,没有恢复成初值1。切换到消费者进程后,Consumer 进程执行P(full)成功,但其执行P(mutex)时由于Producer 正在访问缓冲区,所以不成功,阻塞在信号量mutex 上。生产者进程和消费者进程两者均无法继续执行,相互等待对方释放资源,会产生死锁。 在生产者和消费者进程中,V 操作的次序无关紧要,不会出现死锁现象。 4、答:

实验二进程同步

实验二进程同步演示 一、实验目的 ?深入掌握进程同步机制——信号量的应用; ?掌握Windows编程中信号量机制的使用方法; ?可进行简单的信号量应用编程。 二、实验工具 Windows系统+ VC++ 6.0 三、实验内容 1、复习教材上信号量机制的定义与应用,复习经典进程同步问题——生产者消费者问题及其同步方案; 2、验证后附的参考代码pc.cpp(生产者消费者问题),掌握Windows系统中信号量的定义与使用方法; 注意: (1)代码中生产者和消费者所做的工作用过程Producer和Consumer描述,并通过创建线程的方法创建3个生产者线程和1个消费者线程,具体创建方法:CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);其中第3个参数就是指定该线程所做的工作为过程Producer; (2)问题中设置了三个信号量g_hMutex(用于互斥访问临界区buffer)、 g_hFullSemaphore、g_hEmptySemaphore(用于控制同步的资源信号量),先声明,再定义,最后使用。互斥信号量和资源信号量的定义方法不同: g_hMutex = CreateMutex(NULL,FALSE,NULL); 互斥信号量最开始没有指定针对那个资源g_hFullSemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL); 其中第2和3个参数为信号量的初始值和最大值 信号量的使用方法:WaitForSingleObject为信号量的P操作,每对一个信号量执行该操作,则信号量值减1,并判断减1后值是否仍大于等于0,如是则该操作成功,否则进程阻塞;ReleaseSemaphore为信号量的V操作,每执行一次将该信号量的值加1,并起到唤醒作用。如: WaitForSingleObject(g_hFullSemaphore,INFINITE); … ReleaseSemaphore(g_hEmptySemaphore,1,NULL);

实验三 进程间通信

实验三进程间通信(2学时) 一、实验目的 (1)了解什么是信号。 (2)熟悉LINUX系统中进程之间软中断通信的基本原理。 (3)熟悉LINUX支持的管道通信方式。 二、实验内容 (1)编写一段程序,使其现实进程的软中断通信。 即:使用系统调用fork()创建两个子进程,再用系统调用signal()让父进程捕捉键盘上来的中断信号(即按 ctrl+c 键);当捕捉到中断信号后,父进程用系统调用kill( )向两个子进程发出信号,子进程捕捉到信号后,分别输出下列信息后终止: Child Process11 is killed by Parent! Child Process12 is killed by Parent! 父进程等待两个子进程终止后,输出如下的信息后终止 Parent Process is killed! 要求:运行以下参考程序并分析结果。 <参考程序> #include #include #include #include void waiting(),stop(),alarming(); int wait_mark; main() { int p1,p2; if(p1=fork()) /*创建子进程p1*/ { if(p2=fork()) /*创建子进程p2*/ { //父进程 wait_mark=1; signal(SIGINT,stop); /*接收到^c信号,转stop*/

signal(SIGALRM,alarming);/*接受SIGALRM*/ waiting(); kill(p1,16); /*向p1发软中断信号16*/ kill(p2,17); /*向p2发软中断信号17*/ wait(0); /*同步*/ wait(0); printf("parent process is killed!\n"); exit(0); //会暂时停止目前进程的执行,直到有信号来到或子进程结束。 } else { wait_mark=1; signal(17,stop); signal(SIGINT,SIG_IGN); /*忽略 ^c信号*/ while (wait_mark!=0); lockf(1,1,0); printf("child process2 is killed by parent!\n"); lockf(1,0,0); exit(0); } } else { wait_mark=1; signal(16,stop); signal(SIGINT,SIG_IGN); /*忽略^c信号*/ while (wait_mark!=0); lockf(1,1,0); printf("child process1 is killed by parent!\n"); lockf(1,0,0); exit(0); } } void waiting() { sleep(5); if (wait_mark!=0) kill(getpid(),SIGALRM); } void alarming()

进程同步实验报告

实验三进程的同步 一、实验目的 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. 实验目的 ⑴使用EOS的信号量,编程解决生产者 消费者问题,理解进程同步的意义。 ⑵调试跟踪EOS信号量的工作过程,理解进程同步的原理。 ⑶修改EOS的信号量算法,使之支持等待超时唤醒功能(有限等待),加深理解进程同步的原理。 3. 实验类型 验证+设计 4. 实验内容 ⑴准备实验 ⑵使用EOS的信号量解决生产者-消费者问题 ⑶调试EOS信号量的工作过程 ①创建信号量 ②等待释放信号量 ③等待信号量(不阻塞) ④释放信号量(不唤醒) ⑤等待信号量(阻塞) ⑥释放信号量(唤醒) ⑷修改EOS的信号量算法 二、实验环境 WindowsXP + EOS集成实验环境 三、实验过程 1. 设计思路和流程图

图4-1.整体试验流程图

图4-2.Main 函数流程图、生产者消费、消费者流程图 2. 算法实现 3. 需要解决的问题及解答 (1). 思考在ps/semaphore.c 文件内的PsWaitForSemaphore 和PsReleaseSemaphore 函数中,为什么要使用原子操作?

答:在执行等待信号量和释放信号量的时候,是不允许cpu响应外部中断的,如果此时cpu响应了外部中断,会产生不可预料的结果,无法正常完成原子操作。 (2). 绘制ps/semaphore.c文件内PsWaitForSemaphore和PsReleaseSemaphore函数的流程图。 (3).P143生产者在生产了13号产品后本来要继续生产14号产品,可此时生产者为什么必须等待消费者消费了4号产品后,才能生产14号产品呢?生产者和消费者是怎样使用同步对象来实现该同步过程的呢? 答:这是因为临界资源的限制。临界资源就像产品仓库,只有“产品仓库”空闲生产者才能生产东西,有权向里面放东西。所以它必须等到消费者,取走产品,“产品空间”(临界资源)空闲时,才继续生产14号产品。 (4). 根据本实验3.3.2节中设置断点和调试的方法,自己设计一个类似的调试方案来验证消费者线程在消费24号产品时会被阻塞,直到生产者线程生产了24号产品后,消费者线程才被唤醒并继续执行的过程。 答:可以按照下面的步骤进行调试 (1) 删除所有的断点。 (2) 按F5启动调试。OS Lab会首先弹出一个调试异常对话框。 (3) 在调试异常对话框中选择“是”,调试会中断。 (4) 在Consumer函数中等待Full信号量的代码行(第173行)WaitForSingleObject(FullSemaphoreHandle, INFINITE); 添加一个断点。 (5) 在“断点”窗口(按Alt+F9打开)中此断点的名称上点击右键。 (6) 在弹出的快捷菜单中选择“条件”。 (7) 在“断点条件”对话框(按F1获得帮助)的表达式编辑框中,输入表达式“i == 24”。 (8) 点击“断点条件”对话框中的“确定”按钮。 (9) 按F5继续调试。只有当消费者线程尝试消费24号产品时才会在该条件断点处中断。 4. 主要数据结构、实现代码及其说明 修改PsWaitForSemaphore函数 if (Semaphore->Count>0){ Semaphore->Count--; flag=STATUS_SUCCESS; }//如果信号量大于零,说明尚有资源,可以为线程分配 else flag=PspWait(&Semaphore->WaitListHead, Milliseconds); KeEnableInterrupts(IntState); // 原子操作完成,恢复中断。 return flag; }//否则,说明资源数量不够,不能再为线程分配资源,因此要使线程等待 修改PsReleaseSemaphore函数 if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) {

操作系统进程创建及通信实验报告

武汉工程大学计算机科学与工程学院 《操作系统》实验报告[Ⅰ]

一、实验目的 创建进程,实现进程消息通信和共享内存通信,了解进程的创建、退出和获取进程信。了解什么是映像文件、管道通信及其作用,掌握通过内存映像文件和管道技术实现进程通信。 二、实验内容 本例用三种方法实现进程通信,仅用于示例目的,没有进行功能优化。 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中,实现进程间的一般通信就是使用动态数据交换DDE,实现起来就比较简单,但是要创建映像文件和管道文件就比较繁琐,可以根据不同的需求采用不同的语言。 五、程序部分源代码: 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);

相关文档
最新文档