北京工业大学操作系统实验报告.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子进程中连续发消息类型为10~1的十条消息。
然后在server
升级会员 