操作系统linux版实验报告.docx
《操作系统linux版实验报告.docx》由会员分享，可在线阅读，更多相关《操作系统linux版实验报告.docx（42页珍藏版）》请在冰点文库上搜索。
操作系统linux版实验报告
操作系统实验报告（Linux版）
网络142豹142999
实验一观察Linux进程状态
一、实验目的
在本实验中学习Linux操作系统的进程状态，并通过编写一些简单代码来观察各种情况下，Linux进程的状态，进一步理解进程的状态及其转换机制。
二、实验环境
硬件环境：
计算机一台，局域网环境；
软件环境：
LinuxUbuntu操作系统，gcc编译器。
（四）查看“不可中断阻塞”状态（D）
创建一个C程序，如uninter_status.c，让其睡眠30s
代码：
#include
#include
intmain（）
{
inti=0,j=0,k=0;
for（i=0;i<1000000;i++）
{
for（j=0;j<1000000;j++）
{
k++;
k--;
}
}
}
实验结果:
（二）查看“暂停”状态（T）
运行run_status进程，其进入R状态：
代码同上:
（三）查看“可中断阻塞”状态（S）
创建一个C程序，如interruptiblie_status.c，让其睡眠30s
编译，后台运行该程序（后接&符号），并使用ps命令查看运行状态
代码:
#include
#include
intmain（）
{
sleep（30）;
return;
}
实验结果:
（四）查看“不可中断阻塞”状态（D）
创建一个C程序，如uninter_status.c，让其睡眠30s
编译，后台运行该程序（后接&），并使用ps命令查看运行状态
代码:
#include
#include
intmain（）
{
if（vfork（）==0）
{
sleep（300）;
return;
}
}
实验结果：
（五）查看“僵尸”进程（Z）
创建一个C程序，如zombie_status.c，在其中创建一个子进程，并让子进程迅速结束，而父进程陷入阻塞
编译，后台运行该程序（后接&），并使用ps命令查看运行状态（30s）
代码：
#include
#incldue
intmain（）
{
if（fork（））
{
sleep（300）;
}
}
实验结果：
实验二观察Linux进程/线程的异步并发执行
一、实验目的
通过本实验学习如何创建Linux进程及线程，通过实验，观察Linux进程及线程的异步执行。
理解进程及线程的区别及特性，进一步理解进程是资源分配单位，线程是独立调度单位。
二、实验环境
硬件环境：
计算机一台，局域网环境；
软件环境：
LinuxUbuntu操作系统，gcc编译器。
三、实验容和步骤
1、进程异步并发执行
编写一个C语言程序，该程序首先初始化一个count变量为1，然后使用fork函数创建两个子进程，每个子进程对count加1后，显示“Iamson,count=x”或“Iamdaughter,count=x”,父进程对count加1之后，显示“Iamfather,count=x”,其中x使用count值代替。
最后父进程使用waitpid等待两个子进程结束之后退出。
编译连接后，多次运行该程序，观察屏幕上显示结果的顺序性，直到出现不一样的情况为止，并观察每行打印结果中count的值。
代码：
#include
#include
intmain（）
{
pid_tson_pid,daughter_pid;
intcount=1;
son_pid=fork（）;
if（son_pid==0）
{
count++;
printf（"iamson,count=%d\n",count）;
}
else
{
daughter_pid=fork（）;
if（daughter_pid==0）
{
count++;
printf（"iamdaughter,count=%d\n",count）;
}
else
{
count++;
printf（"iamfather,count=%d\n",count）;
waitpid（son_pid,NULL,0）;
waitpid（daughter_pid,NULL,0）;
}
}
}
2、线程异步并发执行
编写一个C语言程序，该程序首先初始化一个count变量为1，然后使用pthread_create函数创建两个线程，每个线程对count加1后，显示“Iamson,count=x”或“Iamdaughter,count=x”,父进程对count加1之后，显示“Iamfather,count=x”,其中x使用count值代替。
最后父进程使用pthread_join等待两个线程结束之后退出。
编译连接后，多次运行该程序，观察屏幕上显示结果的顺序性，直到出现不一样的情况为止，并观察每行打印结果中count的值。
代码：
#include
#include
#include
void*daughter（void*num）
{
int*a=（int*）num;
*a+=1;
printf（"iamdaughter,count=%d\n",*a）;
}
void*son（void*num）
{
int*a=（int*）num;
*a+=1;
printf（"iamson,count=%d\n",*a）;
}
intmain（）
{
pthread_tson_tid,daughter_tid;
intcount=1;
pthread_create（&son_tid,NULL,son,&count）;
pthread_create（&daughter_tid,NULL,daughter,&count）;
count++;
printf（"iamparent,count:
=%d\n",count）;
pthread_join（son_tid,NULL）;
pthread_join（daughter_tid,NULL）;
return0;
}
实验结果：
实验三使用信号量进行互斥与同步
一、实验目的
本实验介绍在Linux中使用信号量进行进程同步、互斥的方法。
读者可以通过实验进一步理解进程间同步与互斥、临界区与临界资源的概念与含义，并学会Linux信号量的基本使用方法。
二、实验环境
硬件环境：
计算机一台，局域网环境；
软件环境：
LinuxUbuntu操作系统，gcc编译器。
三、实验容和步骤
三、实验容和步骤
（一）参考：
POSIX以及SystemV
SystemV：
Unix众多版本中的一支，最初由AT&T定义，目前为第四个版本，其中定义了较为复杂的API。
POSIX：
PortableOperatingSystemInterface，IEEE为了统一Unix接口而定义的标准，定义了统一的API接口。
Linux即支持SystemAPI，又支持POSIXAPI
（二）实验步骤
step1：
通过实例查看不使用互斥时的情况（假设文件命名为no_sem.c）
编译，同时运行两个进程，显示结果
代码：
#include
#include
intmain（intargc,char*argv[]）
{
charmessage='x';
inti=0;
if（argc>1）{
message=argv[1][0];
}
for（i=0;i<10;i++）{
printf（"%c",message）;
fflush（stdout）;
sleep（rand（）%3）;
printf（"%c",message）;
fflush（stdout）;
sleep（rand（）%2）;
}
sleep（10）;
exit;
}
实验结果：
step2：
使用信号量来对临界资源进行互斥（假设文件命名为with_sem.c）
编译，同时运行两个进程。
观察X和O的出现规律，并分析原因。
代码：
#include
#include
#include
#include
#include
#include
#include
intmain（intargc,char*argv[]）
{
charmessage='x';
inti=0;
if（argc>1）
{
message=argv[1][0];
}
sem_t*mutex=sem_open（"mysem",O_CREAT,0666,1）;
for（i=0;i<10;i++）
{
sem_wait（mutex）;
printf（"%c",message）;
fflush（stdout）;
sleep（rand（）%3）;
printf（"%c",message）;
fflush（stdout）;
sem_post（mutex）;
sleep（rand（）%2）;
}
sleep（10）;
sem_close（mutex）;
sem_unlink（"mysem"）;
exit（0）;
}
实验结果：
step3：
使用信号量来模拟下象棋红黑轮流走子的情况
编写两个C语言程序black_chess.c以及red_chess.c，分别模拟下象棋过程中红方走子和黑方走子过程。
走子规则：
红先黑后，红、黑双方轮流走子，到第10步，红方胜，黑方输。
代码:
红色棋
#include
#include
#include
#include
#include
#include
#include
intmain（intargc,char*argv[]）
{
inti=0;
sem_t*hei=sem_open（"chess_black_sem",O_CREAT,0666,1）;
sem_t*hong=sem_open（"chess_red_sem",O_CREAT,0666,0）;
for（i=0;i<10;i++）
{
sem_wait（hei）;
if（i!
=9）{
printf（"Redchesshadmoved,black,chessgo!
\n"）;
}
else{
printf（"Redchesswin!
\n"）;
}
fflush（stdout）;
sem_post（hong）;
}
sleep（10）;
sem_close（hei）;
sem_close（hong）;
sem_unlink（"chess_red_sem"）;
sem_unlink（"chess_black_sem"）;
exit（0）;
}
黑色棋：
#include
#include
#include
#include
#include
#include
#include
intmain（intargc,char*argv[]）
{
inti=0;
sem_t*hei=sem_open（"chess_black_sem",O_CREAT,0666,1）;
sem_t*hong=sem_open（"chess_red_sem",O_CREAT,0666,0）;
for（i=0;i<10;i++）
{
sem_wait（hong）;
if（i!
=9）{
printf（"Blackchesshadmoved,redchessgo!
\n"）;
}
else{
printf（"Blackchesswin!
\n"）;
}
fflush（stdout）;
sem_post（hei）;
}
sleep（10）;
sem_close（hei）;
sem_close（hong）;
sem_unlink（"chess_red_sem"）;
sem_unlink（"chess_black_sem"）;
exit（0）;
}
实验结果：
实验四作业调度算法模拟
一、实验目的
（1）掌握周转时间、等待时间、平均周转时间等概念及其计算方法。
（2）理解五种常用的进程调度算法（FCFS、SJF、HRRF、HPF、RR），区分算法之间的差异性，并用C语言模拟实现各算法。
（3）了解操作系统中高级调度、中级调度和低级调度的区别和联系。
二、实验环境
硬件环境：
计算机一台，局域网环境；
软件环境：
LinuxUbuntu操作系统，gcc编译器。
三、实验容和步骤
本实验所选用的调度算法均默认为非抢占式。
实验所用的测试数据如下表所示。
本实验所用的测试数据如下表所示
表实验测试数据
作业Id
到达时间
执行时间
优先权
1
800
50
0
2
815
30
1
3
830
25
2
4
835
20
2
5
845
15
2
6
700
10
1
7
820
5
0
作业的数据结构：
typedefstructnode
{
intnumber;//作业号
intreach_time;//作业抵达时间
intneed_time;//作业的执行时间
intprivilege;//作业优先权
floatexcellent;//响应比
intstart_time;//作业开始时间
intwait_time;//等待时间
intvisited;//作业是否被访问过
boolisreached;//作业是否已经抵达
}job;
代码：
#include
#include
#include
#include
//最大作业数量
constintMAXJOB=50;
//作业的数据结构
typedefstructnode
{
intnumber;//作业号
intreach_time;//作业抵达时间
intneed_time;//作业的执行时间
intprivilege;//作业优先权
floatexcellent;//响应比
intstart_time;//作业开始时间
intwait_time;//等待时间
intvisited;//作业是否被访问过
boolisreached;//作业是否抵达
}job;
jobjobs[50];//作业序列
intquantity;//作业数量
//初始化作业序列
voidinitial_jobs（）
{
inti;
for（i=0;i{
jobs[i].number=0;
jobs[i].reach_time=0;
jobs[i].privilege=0;
jobs[i].excellent=0;
jobs[i].start_time=0;
jobs[i].wait_time=0;
jobs[i].visited=0;
jobs[i].isreached=false;
}
quantity=0;
}
//重置全部作业信息
voidreset_jinfo（）
{
inti;
for（i=0;i{
jobs[i].start_time=0;
jobs[i].wait_time=0;
jobs[i].visited=0;
}
}
//查找当前current_time已到达未执行的最短作业,若无返回-1
intfindminjob（jobjobs[],intcount）
{
intminjob=-1;//=jobs[0].need_time;
intminloc=-1;
inti;
for（i=0;i{
if（minloc==-1）{
if（jobs[i].isreached==true&&jobs[i].visited==0）{
minjob=jobs[i].need_time;
minloc=i;
}
}
elseif（minjob>jobs[i].need_time&&jobs[i].visited==0&&jobs[i].isreached==true）
{
minjob=jobs[i].need_time;
minloc=i;
}
}
returnminloc;
}
//查找最早到达作业，若全部到达返回-1.
intfindrearlyjob（jobjobs[],intcount）
{
intrearlyloc=-1;
intrearlyjob=-1;
inti;
for（i=0;i{
if（rearlyloc==-1）{
if（jobs[i].visited==0）{
rearlyloc=i;
rearlyjob=jobs[i].reach_time;
}
}
elseif（rearlyjob>jobs[i].reach_time&&jobs[i].visited==0）
{
rearlyjob=jobs[i].reach_time;
rearlyloc=i;
}
}
returnrearlyloc;
}
//读取作业数据
voidreadJobdata（）
{
FILE*fp;
charfname[20];
inti;
//输入测试文件文件名
printf（"pleaseinputjobdatafilename\n"）;
scanf（"%s",fname）;
if（（fp=fopen（fname,"r"））==NULL）
{
printf（"error,openfilefailed,pleasecheckfilename:
\n"）;
}
else
{
//依次读取作业信息
while（!
feof（fp））
{
if（fscanf（fp,"%d%d%d%d",&jobs[quantity].number,&jobs[quantity].reach_time,&jobs[quantity].need_time,&jobs[quantity].privilege）==4）
quantity++;
}
//打印作业信息
printf（"outputtheoriginjobdata\n"）;
printf（"---------------------------------------------------------------------\n"）;
printf（"\tjobID\treachtime\tneedtime\tprivilege\n"）;
for（i=0;i{
printf（"\t%-8d\t%-8d\t%-8d\t%-8d\n",jobs[i].number,jobs[i].reach_time,jobs[i].need_time,jobs[i].privilege）;
}
}
}
//FCFS
voidFCFS（）
{
inti;
intcurrent_time=0;
intloc;
inttotal_waitime=0;
inttotal_roundtime=0;
//获取最近到达的作业
loc=findrearlyjob（jobs,quantity）;
//输出作业流
printf（"\n\nFCFS算法作业流\n"）;
printf（"------------------------------------------------------------------------\n"）;
printf（"\tjobID\treachtime\tstarttime\twaittime\troundtime\n"）;
current_time=jobs[loc].reach_time;
//每次循环找出最先到达的作业并打印相关信息
for（i=0;i{
if（jobs[loc].reach_time>current_time）
{
jobs[loc].start_time=jobs[loc].reach_time;
current_time=jobs[loc].reach_time;
}
else
{
jobs[loc].start_time=current_time;
}
jobs[loc].wait_time=current_time-jobs[loc].reach_time;
printf（"\t%-8d\t%-8d\t%-8d\t%-8d\t%-8d\n",loc+1,jobs[loc].reach_time,jobs[loc].start_time,jobs[loc].wait_time,
jobs[loc].wait_time+jobs[loc].need_time）;
jobs[loc].visited=1;
current_time+=jobs[loc].need_time;
total_waitime+=jobs[loc].wait_time;
total_roundtime=total_roundtime+jobs[loc].wait_time+jobs[loc].need_time;
//获取剩余作业中最近到达作业
loc=findrearlyjob（jobs,quantity）;
}
printf（"总等待时间:
%-8d总周转时间:
%-8d\n",total_waitime,total_roundtime）;
printf（“平均等待时间:
%4.2f平均周转时间:
%4.2f\n",（float）total_waitime/（quantity）,（float）total_roundtime/（quantity））;
}
//短作业优先作业调度
voidSFJschdulejob（jobjobs[],intcount）
{
}
intmain（）
{
initial_jobs（）;
r
升级会员 