操作系统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