北京工业大学操作系统实验报告材料.docx
- 文档编号:4793555
- 上传时间:2022-12-09
- 格式:DOCX
- 页数:28
- 大小:352.93KB
北京工业大学操作系统实验报告材料.docx
《北京工业大学操作系统实验报告材料.docx》由会员分享,可在线阅读,更多相关《北京工业大学操作系统实验报告材料.docx(28页珍藏版)》请在冰豆网上搜索。
北京工业大学操作系统实验报告材料
操作系统实验报告
姓名:
xxx
学号:
110703xx
完成时间:
2013年11月21日
目录:
实验一:
UNIX/LINUIX入门…………………………………………………………………………………………..3
实验二:
进程管理………………………………………………………………………………………………………..5
实验三:
线程的管理…………………………………………………………………………………………………..11
实验四:
利用信号量实现进程间通信…………………………………………………………………….….15
实验五:
基于消息队列和共享内存的进程间通信……………………………………………….…...20
实验六:
一个进程启动另一个程序的执行…………………………………………………………..……25
实验一UNIX/LINUIX入门
一、实验目的
了解UNIX/LINUX运行环境,熟悉UNIX/LINUX的常用基本命令,熟悉和掌握UNIX/LINUX下c语言程序的编写、编译、调试和运行方法。
二、实验内容
1、熟悉UNIX/LINUX的常用基本命令如ls、who、pwd、ps等。
2、练习UNIX/LINUX的文本行编辑器vi的使用方法
3、熟悉UNIX/LINUX下c语言编译器cc/gcc的使用方法。
用vi编写一个简单的显示“Hello,World!
”c语言程序,用gcc编译并观察编译后的结果,然后运行它。
三、实验要求
按照要求编写程序,放在相应的目录中,编译成功后执行,并按照要求分析执行结果,并写出实验报告。
四、实验设计
代码如下:
#include
intmain(){
printf("Hello,world");
return0;
}
五、运行结果
六、收获及机会
此次实验让我熟悉了c语言编译器cc/gcc的使用方法。
七、参考资料
《实验指导书》
实验二进程管理
一、实验目的
加深对进程概念的理解,明确进程与程序的区别;进一步认识并发执行的实质
二、实验内容
(1)进程创建
编写一段程序,使用系统调用fork()创建两个子进程。
当此程序运行时,在系统中有一
个父进程和两个子进程活动。
让每一个进程在屏幕上显示一个字符:
父进程显示“a“;子进
程分别显示字符”b“和字符“c”。
试观察记录屏幕上的显示结果,并分析原因。
(2)进程控制
修改已编写的程序,将每一个进程输出一个字符改为每一个进程输出一句话,再观察程
序执行时屏幕上出现的现象,并分析原因。
(3)进程的管道通信
编写程序实现进程的管道通信。
使用系统调用pipe()建立一个管道,二个子进程P1和
P2分别向管道各写一句话:
Child1issendingamessage!
Child2issendingamessage!
父进程从管道中读出二个来自子进程的信息并显示(要求先接收P1,再接收P2)。
三、实验要求
按照要求编写程序,放在相应的目录中,编译成功后执行,并按照要求分析执行结果,
并写出实验报告。
四、实验设计
(1)进程创建
使用fork()创建两个子进程,父进程等待两个子进程执行完在运行。
(2)进程控制
使用fork()创建两个子进程,父进程等待两个子进程分别输出一句话在运行。
(3)进程的管道通信
建立一个管道。
在程序中先建立一个子进程,然后向管道中输入数据,然后从子进程中退出到父进程,读出管道数据,然后再建立一个子进程,写入数据,再读出,即可。
代码如下:
(1)进程创建:
#include
#include
voidmain(){
intpid1,pid2;
pid1=fork();
if(pid1<0){
printf("Fork1failed!
!
");
}
if(0==pid1){
printf("b");
exit(0);
}
if(pid1>0){
wait(NULL);
pid2=fork();
if(pid2<0){
printf("Fork2failed!
!
");
}
if(0==pid2){
printf("c");
exit(0);
}
if(pid2>0){
wait(NULL);
printf("a");
exit(0);
}
}
}
(2)进程控制:
#include
#include
voidmain(){
intpid1,pid2;
pid1=fork();
if(pid1<0){
printf("Fork1failed!
!
");
}
if(0==pid1){
printf("thisischildb\n");
exit(0);
}
if(pid1>0){
wait(NULL);
pid2=fork();
if(pid2<0){
printf("Fork2failed!
!
");
}
if(0==pid2){
printf("thisischildc\n");
exit(0);
}
if(pid2>0){
wait(NULL);
printf("fathera\n");
exit(0);
}
}
}
(3)进程的管道通信
#include
#include
#include
#include
voidmain(){
intpid1,pid2;
intpfd[2];
char*msg1="Child1issendingamessage!
";
char*msg2="Child2issendingamessage!
";
charbuf[256];
intr,w;
if(pipe(pfd)<0){
printf("pipecreateerror!
\n");
exit
(1);
}
pid1=fork();
if(pid1<0){
printf("Fork1failed!
!
");
}
if(0==pid1){
close(pfd[0]);//write
sleep(3);
if(w=write(pfd[1],msg1,strlen(msg1))<0){
printf("wirteerror!
\n");
exit
(1);
}else{
printf("child1sendmsgtopipe!
\n");
}
exit(0);
}
if(pid1>0){
wait(NULL);
pid2=fork();
if(pid2<0){
printf("Fork2failed!
!
");
}
if(pid2>0){
close(pfd[1]);//read
sleep(3);
if(r=read(pfd[0],buf,256)<0){
printf("readerror!
\n");
exit
(1);
}else{
printf("parentreadfrompipe:
%s\n",buf);
}
wait(NULL);
close(pfd[1]);//read
sleep(3);
if(r=read(pfd[0],buf,256)<0){
printf("readerror!
\n");
exit
(1);
}else{
printf("parentreadfrompipe:
%s\n",buf);
}
}
if(0==pid2){
close(pfd[0]);//write
sleep(6);
if(w=write(pfd[1],msg2,strlen(msg2))<0){
printf("writeerror!
\n");
exit
(1);
}else{
printf("child2sendmsgtopipe!
\n");
}
exit(0);
}
}
}
五、运行结果
(1)进程创建
(2)进程控制
(3)进程的管道通信
六、收获及机会
此次实验让我对进程和管道有了进一步的理解,当需要创建两个子进程的时候,不能直接在第一个子进程中直接fork(),要保证在在父进程用fork()再次创建子进程,否则创建的不是两个子进程而会是3个,关于父子进程的执行顺序,是无法预知的,如果想要先让子进程运行,那么父进程一定要用wait(NULL)语句进行等待;关于管道,只用一个即可,但必须在第一个fork()之前创建,否则父子进程不会共享。
在向管道中写入数据和从管道中读出数据的时候,要控制好管道的读写控制,例如读的时候必先关写,但是又不能关闭读(写)端过多,要确保读(写)的时候总是有端口可读(写),否则的话会造成读(写)失败。
这些是我此次实验最大的收获,还需要在今后的时候发现更多的问题,有更深的理解。
七、参考资料
《实验指导书》
实验三线程的管理
一、实验目的
编写Linux环境下的多线程程序,了解多线程的程序设计方法,掌握最常用的三个函
数pthread_create,pthread_join和pthread_exit的用法
二、实验内容
1、主程序创建两个线程myThread1和myThread2,每个线程打印一句话。
使用pthread_create(&id,NULL,(void*)thread,NULL)完成。
提示:
先定义每个线程的执行体,然后在main中()创建几个线程,最后主线程等待子线程结
束后再退出。
2、创建两个线程,分别向线程传递如下两种类型的参数
传递整型值
传递字符
三、实验要求
按照要求编写程序,放在相应的目录中,编译成功后执行,并按照要求分析执行结果,
并写出实验报告。
四、实验设计
先定义2个线程的带有参数的函数,参数分别为整型(int)和字符型(char),每个函数中打印出相对应线程的话。
在main函数中,利用pthread_create函数创建该两个线程,在函数参数中的第四位,写入想要传进各进程的参数。
然后利用pthread_join等待第二个结束后退出。
代码如下:
1、主程序创建两个线程myThread1和myThread2,每个线程打印一句话。
#include
#include
#include
voidmyThread1(void){
printf("Thisispthread1.\n");
}
voidmyThread2(void){
printf("Thisispthread2.\n");
}
intmain(void){
pthread_tid1,id2;
intret1,ret2;
ret1=pthread_create(&id1,NULL,(void*)myThread1,NULL);
if(0!
=ret1){
printf("Createpthread1error!
\n");
exit
(1);
}
ret2=pthread_create(&id2,NULL,(void*)myThread2,NULL);
if(0!
=ret2){
printf("Createpthread2error!
\n");
exit
(2);
}
pthread_join(id1,NULL);
pthread_join(id2,NULL);
return(0);
}
2、创建两个线程,分别向线程传递如下两种类型的参数
#include
#include
#include
void*myThread1(void*arg){
int*num;
num=(int*)arg;
printf("createparameteris%d.\n",*num);
return(void*)0;
}
void*myThread2(void*arg){
char*ch;
ch=(char*)arg;
printf("createparameteris%c.\n",*ch);
return(void*)0;
}
intmain(void){
pthread_tid1,id2;
intret1,ret2;
intnum=1;
charch='a';
int*p_num=#
char*p_ch=&ch;
ret1=pthread_create(&id1,NULL,myThread1,(void*)p_num);
if(0!
=ret1){
printf("Createpthread1error!
\n");
exit
(1);
}
ret2=pthread_create(&id2,NULL,myThread2,(void*)p_ch);
if(0!
=ret2){
printf("Createpthread2error!
\n");
exit
(2);
}
pthread_join(id1,NULL);
pthread_join(id2,NULL);
return(0);
}
五、运行结果
1、主程序创建两个线程myThread1和myThread2,每个线程打印一句话。
2、创建两个线程,分别向线程传递如下两种类型的参数
六、收获及体会
此次实验让我对线程的创建有了初步的理解,在熟练掌握pthread_create和pthread_join两个函数的应用上,学会了如何向线程中传入参数。
七、参考资料
《实验指导书》
实验四利用信号实现进程间通信
一、实验目的
学习UNIX类(SystemV)操作系统信号机制,编写Linux环境下利用信号实现进程间通信的方法,掌握相关系统调用的使用方法。
二、实验内容
创建4个线程,其中两个线程负责从文件读取数据到公共的缓冲区,另两个线程从缓冲区读取数据作不同的处理(加和乘运算)。
使用信号量控制这些线程的执行。
三、实验要求
按照要求编写程序,放在相应的目录中,编译成功后执行,并按照要求分析执行结果,
并写出实验报告。
四、实验设计
4个线程,两个生产者两个消费者;3个信号量:
信号量n确保消费者不会从空的缓冲区取数;信号量S确保所有参与者之间互斥对缓冲区操作(防止出现两个生产者同时向一个缓冲区部分写,或写的同时有消费者来读的情况);信号量e确保缓冲区满后不会再向其中写。
两个生产者分别从两个文件中读取数据写到缓冲区,两个消费者分别做“+”和“*”操作
代码如下:
#include
#include
#include
#include
#defineDATA1"data1.txt"
#defineDATA2"data2.txt"
#defineMAX_BUFFER5
intin=0;
intout=0;
intcount1=0;
intcount2=0;
intnum_buffer[MAX_BUFFER];
sem_tn;
sem_ts;
sem_te;
void*produceThread1(FILE*fp1){
intnum;
while(fscanf(fp1,"%d",&num)!
=EOF){
sem_wait(&e);
sem_wait(&s);
printf("produceThread1put%dinbuffer[%d].\n",num,in);
num_buffer[in]=num;
in++;
in=in%MAX_BUFFER;
sem_post(&s);
sem_post(&n);
}
}
void*produceThread2(FILE*fp2){
intnum;
while(fscanf(fp2,"%d",&num)!
=EOF){
sem_wait(&e);
sem_wait(&s);
printf("produceThread2put%dinbuffer[%d].\n",num,in);
num_buffer[in]=num;
in++;
in=in%MAX_BUFFER;
sem_post(&s);
sem_post(&n);
}
}
void*consumeThread3(){
intnums[2];
intresult;
while
(1){
sem_wait(&n);
sem_wait(&s);
nums[count1]=num_buffer[out];
printf("consumeThread3Get%dfrombuffer[%d].\n",nums[count1],out);
out++;
out=out%MAX_BUFFER;
count1++;
if(2==count1){
result=nums[0]+nums[1];
printf("%d+%d=%d.\n",nums[0],nums[1],result);
count1=0;
}
sem_post(&s);
sem_post(&e);
}
}
void*consumeThread4(){
intnums[2];
intresult;
while
(1){
sem_wait(&n);
sem_wait(&s);
nums[count2]=num_buffer[out];
printf("consumeThread4Get%dfrombuffer[%d].\n",nums[count2],out);
out++;
out=out%MAX_BUFFER;
count2++;
if(2==count2){
result=nums[0]*nums[1];
printf("%d*%d=%d.\n",nums[0],nums[1],result);
count2=0;
}
sem_post(&s);
sem_post(&e);
}
}
voidmain(){
intret1,ret2,ret3,ret4;
pthread_tid1,id2,id3,id4;
sem_init(&n,0,0);
sem_init(&s,0,1);
sem_init(&e,0,MAX_BUFFER);
FILE*fp1=NULL;
FILE*fp2=NULL;
fp1=fopen(DATA1,"r");
fp2=fopen(DATA2,"r");
if(NULL==fp1){
exit
(1);
}
if(NULL==fp2){
exit
(2);
}
ret1=pthread_create(&id1,NULL,produceThread1,fp1);
if(0!
=ret1){
printf("Createpthread1error!
\n");
exit
(1);
}
ret2=pthread_create(&id2,NULL,produceThread2,fp2);
if(0!
=ret2){
printf("Createpthread2error!
\n");
exit
(2);
}
ret3=pthread_create(&id3,NULL,consumeThread3,NULL);
if(0!
=ret3){
printf("Createpthread3error!
\n");
exit(3);
}
ret4=pthread_create(&id4,NULL,consumeThread4,NULL);
if(0!
=ret4){
printf("Createpthread4error!
\n");
exit(4);
}
pthread_join(id1,NULL);
pthread_join(id2,NULL);
pthread_join(id3,NULL);
pthread_join(id4,NULL);
fclose(fp1);
fclose(fp2);
}
五、运行结果
六、收获及体会
此次实验让我实践了在Linux环境下利用信号量实现生产者消费者问题的解决,掌握了信号量相关函数的使用方法。
七、参考资料
《实验指导书》
实验五基于消息队列和共享内存的进程间通信
一、实验目的
Linux系统的进程通信机构(IPC)允许在任意进程间大批量地交换数据。
本实验的目的是了解和熟悉:
1.Linux支持的消息通信机制及其使用方法
2.Linux系统的共享存储区的原理及使用方法。
二、实验内容
1.消息的创建、发送和接收
使用消息调用msgget()、msgsnd()、msggrev()、msgctrl()编制长度为1K的消息的发送和接收程序。
2.共享存储区的创建、附接和断接
使用系统调用shmget()、shmat()、shmctl(),编制一个与上述功能相同的程序。
三、实验要求
按照要求编写程序,放在相应的目录中,编译成功后执行,并按照要求分析执行结果,
并写出实验报告。
四、实验设计
1.消息队列:
先定义一个消息结构,包含消息类型和文本长度(1024)。
在主函数中,首先获得一个KEY为75的消息的描述符,然后在client子进程中连续发消息
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 北京工业大学 操作系统 实验 报告 材料