搜档网
当前位置:搜档网 › 操作系统OS报告读者与写者问题(进程同步问题)

操作系统OS报告读者与写者问题(进程同步问题)

操作系统OS报告读者与写者问题(进程同步问题)
操作系统OS报告读者与写者问题(进程同步问题)

目录

一、课程设计目的及要求 (1)

二、相关知识 (1)

三、题目分析 (2)

四、概要设计 (4)

五、代码及流程 (5)

六、运行结果 (11)

七、设计心得 (12)

八、参考文献 (12)

一、课程设计目的及要求

读者与写者问题(进程同步问题)

用n 个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求,进行读写操作。请用信号量机制分别实现读者优先和写者优先的读者-写者问题。

读者-写者问题的读写操作限制:

1)写-写互斥;

2)读-写互斥;

3)读-读允许;

写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。

二、相关知识

Windows API:

在本实验中涉及的API 有:

1线程控制:

CreateThread 完成线程创建,在调用进程的地址空间上创建一个线程,以执行指定的函数;它的返回值为所创建线程的句柄。

HANDLE CreateThread(

LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD

DWORD dwStackSize, // initial stack size

LPTHREAD_START_ROUTINE lpStartAddress, // thread

function

LPVOID lpParameter, // thread argument

DWORD dwCreationFlags, // creation option

LPDWORD lpThreadId // thread identifier

);

2 ExitThread 用于结束当前线程。

VOID ExitThread(

DWORD dwExitCode // exit code for this thread

);

3Sleep 可在指定的时间内挂起当前线程。

VOID Sleep(

DWORD dwMilliseconds // sleep time

);

4信号量控制:

WaitForSingleObject可在指定的时间内等待指定对象为可用状态;

DWORD WaitForSingleObject(

HANDLE hHandle, // handle to object

DWORD dwMilliseconds // time-out interval

);

hHandle为等待的对象,也就是实现同步或者互斥的对象。该函数一执行,相应的信号量就减去1,如果信号量小于等于0,那么他一直在循环。

5实现信号量互斥和同步

CreateSemaphore用于创建信号量,根据参数的不同可以利用它实现互斥和同步。

ReleaseSemaphore用于释放信号量,使用后相应的信号量加1

HANDLE CreateSemaphore(

LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,//SD

LONG,lInitialCount, //initial count

LONG,lMaximumCount, //maximum count

LPCTSTR lpName //object name

);

ReleaseSemaphore(

HANDLE hSemaphore, //handle to semaphore

LONG lRelseaseCount, //cont increment amount

LPLONG lpPreviousCount //previous count

);

三、题目分析

将所有的读者和所有的写者分别放进两个等待队列中,当读允许时就让读者队列释放一个或多个读者,当写允许时,释放第一个写者操作。

(1)构筑读者进程和写者进程间的临界区

题目中说的一批数据被多个读者、写者共享使用,允许多个读者同时访问这些数据,但是如果有一个写者在访问数据时,就不允许其他读者或写者使用,所以,对这一批数据既要保证读者和写者互斥使用,也要保证写者与写者互斥使用。也就是说,在读者进程程序中,使用数据的程序段应该构成临界区;在写者进程程序中,使用数据的程序段应该构成临界区。(2)判定是否是第一个读者

根据上面的分析,希望在读者进程中有一个办法能判定请求进入临界区的是否是第一个读者。如果是第一个读者,就对信号量wsem做P操作,以取得和写者的同步。为此,设置一个变量rfirst,初值为0.任何一个读者运行时,都现在rfirst上加1,然后判定他是否取值为1.如果是1,则做P(wrt),否则不做。

(3)判定是否是第一个写者

原理同(2)判定是否为第一个读者。

(4)写者优先问题的解决需要用到的如下的信号量和变量

rsem: 初值为1的互斥信号量,在至少有一个写者准备访问数据时就不允许随后来的读者访问数据

wserm: 初值为1的互斥信号量,之后有一个写者访问数据时其他写者和读者就被阻止对数据的访问

ReadMutex: 创建写者的互斥信号量,初值为1

WriteMutex: 创建读者的互斥信号量,初值为1

z: 初值为1的互斥信号量,在至少有一个写着准备访问数据、且后面已经来一个读者时再来的读者将在这个信号量上等待

rifrrst:读者计数变量,初值为0 wfirst:写者计数变量,初值为0

写者优先的PV原语:

reader(i):

{

P(z);

P(rsem);

P(ReadMutex);

rfirst=rfirst+1;

if(rfirst==1)

P(wsem);

V(ReadMutex);

V(rsem);

V(z);

读取所需数据;

P(ReadMutex);

rfirst=rfirst-1;

if(rfirst==0)

V(wsem);

V(ReadMutex); } Writer():

{

P(WriteMutex);

wfirst=wfirst+1;

if(wfirst==1)

P(rsem);

V(WritedMutex);

P(wsem);

改写所需数据;

V(wsem);

P(WriteMutex);

wfirst=wfirst-1;

if(wfirst==0)

V(rsem);

V(WriteMutex); }

读者写者图3.1读者-写者的完整流程框图

(5)读者优先

与写者优先算法相反,有一个读者优先的算法,即只要有读者在读数据,写者被拒绝在临界区外面,如果有源源不断的写者来,但是只要写者不是第一个,那么写者将会永远被拒绝在临界区外面。

wrt::初值为1的互斥信号量,只要有一个写者访问数据,则其他写者和读者就要被阻止对数据的访问。

mutex:保证读者互斥操作first的信号量,初值为1

first :读者计数变量,初值为0

读者优先的PV原语:

write():

{

P(wrt);

对数据进行修改;

V(wrt);

} read():{

P(mutex);

first = first+1;

if(first == 1)

P(wrt);

V(mutex);

读取所需数据

P(mutex);

first = first+1;

if(first == 0)

V(wrt);

V(mutex);

}

四、概要设计

(1)控制流程

用CheckPersonList(PersonLists)函数检查PersonLists中是否有为创建的进程(读写者)。如果有则创建相应的读写线程

(2)创建读写者

用bool CreateReader(int StartTime,int WorkTime)函数创建读者写者相应的线程,其中由windows提供的函数为CreateThread(NULL,0,ReaderProc,(LPVOID)pPerson,0,&dwThreadID);返回的是DWORD型变量。

在CreateReader(int StartTime,int WorkTime)中还会初始化相应的读写者的基本信息,例如何时申请数据何时读数据何时关闭线程等等。

(3)读写者进程

参见图2.1读者-写者的完整流程图。

(4)同步与互斥

WaitForSingleObject(信号量名字,infinite)和ReleaseSemaphore(信号量名字,1,null)用于实现同步于互斥,执行WaitForSingleObject(信号量名字,infinite)信号量相应的信号量减1,执行ReleaseSemaphore(信号量名字,1,null)恢复1。

五、代码及流程

//写者优先算法

#include

#include

#include

#include

#include

#include

#define MAX_PERSON 10

#define READER 0

#define WRITER 1

#define END -1

#define R READER #define W WRITER

typedef struct _Person

{

HANDLE Thread;

int Type;

int StartTime;

int WorkTime;

int ID;

}Person;

Person Persons[MAX_PERSON]; int NumPerson = 0;

long CurrentTime= 0;

int PersonLists[] = {

1,R,1,3,

2,W,2,5,/*读写互斥*/

3,W,5,5,/*写写互斥*/

4,R,3,5,/*写读互斥*/

5,R,15,2,/*读读不互斥*/

END,

};

int rfirst = 0;

int wfirst = 0;

int NumOfReaders = 0;

int NumOfWriters = 0;

HANDLE rsem;/*初值为1的互斥信号量,在至少有一个写者准备访问数据时就不允许随后来的读者访问数据*/

HANDLE wsem;/*初值为1的互斥信号量,之后有一个写者访问数据时其他写者和读者就被阻止对数据的访问*/

HANDLE z;/*初值为1的互斥信号量,在至少有一个写着准备访问数据、且后面已经来一个读者时再来的读者将在这个信号量上等待*/

HANDLE ReadMutex;/*创建写者的互斥信号量,初值为1*/

HANDLE WriteMutex;/*创建读者的互斥信号量, 初值为1*/

void CheckPersonList(int *pPersonList);/*查看人数,为创建读写者线程*/ bool CreateReader(int StartTime,int WorkTime);

bool CreateWriter(int StartTime,int WorkTime);

DWORD WINAPI ReaderProc(LPVOID lpParam);/*读者进程程序*/

DWORD WINAPI WriterProc(LPVOID lpParam);/*写着进程程序*/

#include "Writerprior.h"

int main()

{

rsem = CreateSemaphore(NULL,1,1,NULL);

wsem = CreateSemaphore(NULL,1,1,NULL);

z = CreateSemaphore(NULL,1,1,NULL);

ReadMutex = CreateSemaphore(NULL,1,1,NULL);

WriteMutex = CreateSemaphore(NULL,1,1,NULL);

CurrentTime = 0;

while(true)//模拟20个时钟周期

{

CheckPersonList(PersonLists);

CurrentTime++;

Sleep(600);

printf("当前时间= %d:\n",CurrentTime);

if(CurrentTime==20)

break;

}

system("pause");

CloseHandle(rsem);

CloseHandle(wsem);

CloseHandle(z);

CloseHandle(ReadMutex);

CloseHandle(WriteMutex);

return 0;

}

void CheckPersonList(int *pPersonLists)

{

int i=0;

int *pList = pPersonLists;

bool P;

while(pList[0] != END)

{

if(pList[2] == CurrentTime)

{

switch(pList[1])

{

case R:

P = CreateReader(pList[2],pList[3]);//创建一个读者

break;

case W:

P = CreateWriter(pList[2],pList[3]);//创建一个写者

break;

}

if(!P)

printf("Create Person %d is wrong\n",pList[0]);

}

pList += 4; // 数组的指针指向第二个人

}

}

DWORD WINAPI ReaderProc(LPVOID lpParam)

{

Person *pPerson = (Person*)lpParam;

pPerson->ID = ++NumOfReaders;

WaitForSingleObject(z,INFINITE);//P(z),其余读者在此排队

printf("\t\t读者%d 申请读数据...\n",pPerson->ID);

WaitForSingleObject(rsem,INFINITE);//P(rsem),一个读者与一个写着再次竞争数据的使用权

//printf("Reader %d is requesting the Shared Buffer...\n",pPerson->ID);

WaitForSingleObject(ReadMutex,INFINITE);//P(ReadMutex),读者请求进入rfirst临界区

rfirst++;

if(rfirst == 1)//是否是第一个读者

{

WaitForSingleObject(wsem,INFINITE);//读者在此处与写者进行同步}

ReleaseSemaphore(ReadMutex,1,NULL);//退出rfirst临界区,V(ReadMutex) ReleaseSemaphore(rsem,1,NULL);

ReleaseSemaphore(z,1,NULL);//V(z)

// 读取所需数据,将现在时间赋值给读者,用以计算结束时间

printf("\t\t读者%d 申请成功\n",pPerson->ID);

pPerson->StartTime = CurrentTime;

printf("\t\t读者%d 正在读数据...\n",pPerson->ID);

while(CurrentTime < pPerson->StartTime + pPerson->WorkTime)

{

// 模拟读数据

}

printf("\t\t读者%d 读完数据退出\n",pPerson->ID);

WaitForSingleObject(ReadMutex,INFINITE);

rfirst--;

if(rfirst == 0) //是最后一个读者?

ReleaseSemaphore(wsem,1,NULL);//没有读者了,写者放行

ReleaseSemaphore(ReadMutex,1,NULL);//退出读者临界区

ExitThread(0);//关闭读者线程

return 0;

}

DWORD WINAPI WriterProc(LPVOID lpParam)//写者进程程序

{

Person *pPerson = (Person*)lpParam;

pPerson->ID = ++NumOfWriters;

printf("\t\t写者%d 正在申请写数据...\n",pPerson->ID);

WaitForSingleObject(WriteMutex,INFINITE);//请求进入写者临界区

wfirst=wfirst++;

if(wfirst==1)

{

WaitForSingleObject(rsem,INFINITE);//一个写者在此与读者取得同步}

ReleaseSemaphore(WriteMutex,1,NULL);//退出rfirst临界区

WaitForSingleObject(wsem,INFINITE);//其他写者在此等候进入写临界区

// 读取所需数据,将现在时间赋值给读者,用以计算结束时间

pPerson->StartTime = CurrentTime;

printf("\t\t写者%d 正在写数据...\n",pPerson->ID);

while(CurrentTime < pPerson->StartTime + pPerson->WorkTime)

{

//模拟写数据

}

printf("\t\t写者%d 写完数据退出\n",pPerson->ID);

ReleaseSemaphore(wsem,1,NULL);//退出进入写临界区

WaitForSingleObject(WriteMutex,INFINITE);//请求进入wfirst临界区

wfirst=wfirst--;

if(wfirst==0)//是最后一个写者?

{

ReleaseSemaphore(rsem,1,NULL);//没有写者了,向读者放行

}

ReleaseSemaphore(WriteMutex,1,NULL);//退出wfirst临界区

ExitThread(0);//关闭写者线程

return 0;

}

bool CreateReader(int StartTime,int WorkTime)

{

DWORD dwThreadID;

Person *pPerson = &Persons[NumPerson];

pPerson->StartTime = StartTime;

pPerson->WorkTime = WorkTime;

pPerson->Type = READER;

NumPerson++;

// 创建一个读者的新线程

pPerson->Thread = CreateThread(NULL,0,ReaderProc,(LPVOID)pPerson,0,&dwThreadID);

if(pPerson->Thread == NULL)

return false;

return true;

}

bool CreateWriter(int StartTime,int WorkTime)

{

DWORD dwThreadID;

if(NumPerson >= MAX_PERSON)

return false;

Person *pPerson = &Persons[NumPerson];

pPerson->StartTime = StartTime;

pPerson->WorkTime = WorkTime;

pPerson->Type = WRITER;

NumPerson++;

// 创建一个写者的新线程

pPerson->Thread = CreateThread(NULL,0,WriterProc,(LPVOID)pPerson,0,&dwThreadID);

if(pPerson->Thread == NULL)

return false;

return true;

}

六、运行结果

图6.1 运行结果

结果分析:

顺序开始时间(s)执行时间(s)

Reader 1 1 3

2 3 5

3 15 2

Writer 1 2 5

2 5 5

表6.1

如上表,第一个读者1到达时间是第1s,执行时间是3s,即在第4s的时候结束,而在第2s的时候就写者1到达。这时候,写者1被阻挡在z的临界区外面。在第3s的时候,读者2到达,由于写者1在前面,所以同样被阻挡在z外面,在第4s读者1运行结束,写者1开始写数据,这是读者2被阻挡在rsem的临界区外面,在第5s的时候到达第二个写者,

由于写写互斥,所以被阻挡在写者wsem的临界区外面。第14s写者2退出,读者2才开始读数据。读者3在第15s的时候到达,由于读读不存在互斥,所以两个读线程同时进行,知道第19s时读者2结束,整个模拟结束。(过程请参考图6.2)

图6.2 程序过程图

七、设计心得

通过这次操作系统的课程设计,我研究了读者与写者问题,进一步深入了解了同步与互斥机制。比如什么是同步,什么是互斥,什么是信号量等等。

课程设计和平时的实验课比较起来有很大的差距,实验课只是将这一章的一部分内容练习操作一遍,而课程设计需要的是他们综合起来的东西,这要更难一些。

总体来说我认为操作系统这门学科在计算机科学当是中非常重要的。他将我们学过的编程语言联系起来,可以说是第一次利用C语言利用windows的API与系统进行“沟通”。

总而言之,这次操作系统的课程设计收获颇丰,复习了许多东西,也从新学会了许多东西。我想这也许就是课程设计的最终目的吧。

八、参考文献

[1]刘振安、刘燕君著.《C++程序设计课程设计》.北京: 机械工业出版社,2004

[2][美]Abraham Silberschatz, Peter Baer Galvin, Greg Gagne 著. 郑扣根译. 操作系统概念

(第六版). 北京:高等教育出版社,2004

[3]陈向群,向勇等. Windows操作系统原理(第二版). 北京:机械工业出版社,2004.

操作系统OS报告读者与写者问题(进程同步问题)

目录 一、课程设计目的及要求 (1) 二、相关知识 (1) 三、题目分析 (2) 四、概要设计 (4) 五、代码及流程 (5) 六、运行结果 (11) 七、设计心得 (12) 八、参考文献 (12)

一、课程设计目的及要求 读者与写者问题(进程同步问题) 用n 个线程来表示n个读者或写者。每个线程按相应测试数据文件的要求,进行读写操作。请用信号量机制分别实现读者优先和写者优先的读者-写者问题。 读者-写者问题的读写操作限制: 1)写-写互斥; 2)读-写互斥; 3)读-读允许; 写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态后才能开始读操作。 二、相关知识 Windows API: 在本实验中涉及的API 有: 1线程控制: CreateThread 完成线程创建,在调用进程的地址空间上创建一个线程,以执行指定的函数;它的返回值为所创建线程的句柄。 HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD DWORD dwStackSize, // initial stack size LPTHREAD_START_ROUTINE lpStartAddress, // thread function LPVOID lpParameter, // thread argument DWORD dwCreationFlags, // creation option LPDWORD lpThreadId // thread identifier ); 2 ExitThread 用于结束当前线程。 VOID ExitThread( DWORD dwExitCode // exit code for this thread ); 3Sleep 可在指定的时间内挂起当前线程。 VOID Sleep( DWORD dwMilliseconds // sleep time ); 4信号量控制: WaitForSingleObject可在指定的时间内等待指定对象为可用状态; DWORD WaitForSingleObject( HANDLE hHandle, // handle to object DWORD dwMilliseconds // time-out interval );

实验一进程调度实验报告书

淮海工学院计算机工程学院实验报告书 课程名:《操作系统原理A》 题目:进程调度 班级:软件132 学号:2013122907 姓名:孙莹莹

操作系统原理实验——进程调度实验报告 一、目的与要求 1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C 语言编写一个进程调度模拟程序,使用优先级或时间片轮转法实现进程调度。本实验可加深对进程调度算法的理解。 2)按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果) 3)于2015年4月18日以前提交本次实验报告(含电子和纸质报告,由学习委员以班为单位统一打包提交)。 二、实验内容或题目 1)设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。 2)模拟调度程序可任选两种调度算法之一实现(有能力的同学可同时实现两个调度算法)。 3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。 4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。 三、实验步骤与源程序 (1)流程图

(2)实验步骤 1)PCB的结构:优先级算法中,设PCB的结构如下图所示,其中各数据项的含义如下: Id:进程标识符号,取值1—5。 Priority:优先级,随机产生,范围1—5。 Used:目前已占用的CPU时间数,初值为0;当该进程被调用执行时,每执行一个时间片,Used加1。 Need:进程尚需的CPU时间数,初值表示该进程需要运行的总时间,取值范围为5—10。并随机产生,每运行一个时间片need减1;need为0则进程结束。 Status:进程状态R(运行),W(就绪),F(完成);初始时都处于就绪状态。 Next:指向就绪队列中下一个进程的PCB的指针。 2)初始状态及就绪队列组织: 5个进程初始都处于就绪状态,进程标识1—5,used初值都为0。各进程的优先级随机产生,范围1—5。处于就绪状态的进程,用队列加以组织,队列按优先级由高到低依次排列,队首指针设为head,队尾指针为tail。 3)调度原则以及运行时间的处理: 正在执行的进程每执行一个时间片,其优先级减1(允许优先级为负)。进程调度将在以下情况发生:当正在运行的程序其优先级小于就绪队列队首进程的优先级时。程序中进程的运行时间以逻辑时间片为单位。

操作系统进程同步实验报告

实验三:进程同步实验 一、实验任务: (1)掌握操作系统的进程同步原理; (2)熟悉linux的进程同步原语; (3 )设计程序,实现经典进程同步问题。 二、实验原理: (1)P、V操作 PV操作由P操作原语和V操作原语组成(原语是不可中断的过程) ,对信号量进行操作,具体定义如下: P( S):①将信- 号量S的值减1,即S=S-1; ②如果S30,则该进程继续执行;否则该进程置为等待状态,排入等待队列。 V( S):①将信号量S的值加1,即S=S+1 ; ②如果S>0,则该进程继续执行;否则释放队列中第一个等待信号量的进程。 (2)信号量 信号量(semaphore )的数据结构为一个值和一个指针,指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时,表示当前可用资源的数量;当它的值小于0时,其绝对值表示等待使用该资源的进程个数。注意,信号量的 值仅能由PV操作来改变。 一般来说,信号量S30时,S表示可用资源的数量。执行一次P操作意味着请求分配一 个单位资源,因此S的值减1;当S<0时,表示已经没有可用资源,请求者必须等待别的进程释放该类资源,它才能运行下去。而执行一个V操作意味着释放一个单位资源,因此S 的值加1;若S均,表示有某些进程正在等待该资源,因此要唤醒一个等待状态的进程,使之运行下去。 (3)linux的进程同步原语 ①wait();阻塞父进程,子进程执行; ②#in clude #in clude key_t ftok (char*path name, char proj) ;它返回与路径path name 相对应的一个键值。 ③int semget(key_t key, int n sems, int semflg) 参数key是一个键值,由ftok获得,唯一标识一个信号灯集,用法与msgget()中的key 相同;参数nsems指定打开或者新创建的信号灯集中将包含信号灯的数目;semflg参数是一些标志位。参数key和semflg的取值,以及何时打开已有信号灯集或者创建一个新的信号灯集与msgget()中的对应部分相同。该调用返回与健值key相对应的信号灯集描述字。调用返回:成功返回信号灯集描述字,否则返回-1。 ④int semop(i nt semid, struct sembuf *sops, un sig ned n sops); semid是信号灯集ID , sops指向数组的每一个sembuf结构都刻画一个在特定信号灯上的操作。nsops为sops指向数组的大小。 ⑤int semctl(int semid , int semnum , int cmd , union semun arg) 该系统调用实现对信号灯的各种控制操作,参数semid指定信号灯集,参数cmd指定 具体的操作类型;参数semnum指定对哪个信号灯操作,只对几个特殊的cmd操作有意义;

第二章-操作系统进程(练习题答案)

第二章进程管理 1.操作系统主要是对计算机系统全部 (1) 进行管理,以方便用户、提高计算机使 用效率的一种系统软件。它的主要功能有:处理机管理、存储管理、文件管理、 (2) 管 理和设备管理等。Windows和Unix是最常用的两类操作系统。前者是一个具有图形界面的 窗口式的 (3) 系统软件,后者是一个基本上采用 (4) 语言编制而成的 的系统软件。在 (5) 操作系统控制下,计算机能及时处理由过程控制反馈的信息 并作出响应。 供选答案: (1): A. 应用软件 B. 系统软硬件 C. 资源 D. 设备 (2): A. 数据 B. 作业 C. 中断 D. I/O (3): A. 分时 B. 多任务 C. 多用户 D. 实时 (4): A. PASCAL B. 宏 C. 汇编 D. C (5): A. 网络 B. 分时 C. 批处理 D. 实时 答案:CBBDD 2.操作系统是对计算机资源进行的 (1) 系统软件,是 (2) 的接口。 在处理机管理中,进程是一个重要的概念,它由程序块、 (3) 和数据块三部 分组成,它有3种基本状态,不可能发生的状态转换是 (4) 。 虚拟存储器的作用是允许程序直接访问比内存更大的地址空间,它通常使用 (5) 作为它的一个主要组成部分。 供选答案: (1): A. 输入和输出 B. 键盘操作 C. 管理和控制 D. 汇编和执行 (2): A. 软件和硬件 B. 主机和外设 C. 高级语言和机器语言 D. 用户和计算机 (3): A. 进程控制块 B. 作业控制块 C. 文件控制块 D. 设备控制块 (4): A. 运行态转换为就绪态 B. 就绪态转换为运行态 C. 运行态转换为等待态 D. 等待态转换为运行态 (5): A. 软盘 B. 硬盘 C. CDROM D. 寄存器 答案:CDADB 3.在计算机系统中,允许多个程序同时进入内存并运行,这种方法称为 D。 A. Spodling技术 B. 虚拟存储技术 C. 缓冲技术 D. 多道程序设计技术 4.分时系统追求的目标是 C。 A. 高吞吐率 B. 充分利用内存 C. 快速响应 D. 减少系统开销 5.引入多道程序的目的是 D。

操作系统的进程调度 实验报告

《计算机操作系统2》实验报告 实验一题目:操作系统的进程调度 姓名:学号:12125807 实验日期:2014.12 实验要求: 1.设计一个有n个进程工行的进程调度程序。每个进程由一个进程控制块(PCB)表示。 进程控制块通常应包含下述信息:进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等,且可按调度算法的不同而增删。 2.调度程序应包含2~3种不同的调度算法,运行时可任意选一种,以利于各种算法的分 析比较。 3.系统应能显示或打印各进程状态和参数的变化情况,便于观察诸进程的调度过程 实验目的: 1.进程是操作系统最重要的概念之一,进程调度又是操作系统核心的主要内容。本实习要 求学生独立地用高级语言编写和调试一个简单的进程调度程序。调度算法可任意选择或自行设计。例如,简单轮转法和优先数法等。本实习可加深对于进程调度和各种调度算法的理解。 实验内容: 1.编制和调试示例给出的进程调度程序,并使其投入运行。 2.自行设计或改写一个进程调度程序,在相应机器上调试和运行该程序,其功能应该不亚 于示例。 3.直观地评测各种调度算法的性能。 示例: 1.题目 本程序可选用优先数法或简单轮转法对五个进程进行调度。每个进程处于运行R(run)、就绪W(wait)和完成F(finish)三种状态之一,并假设起始状态都是就绪状态W。为了便于处理,程序进程的运行时间以时间片为单位计算。各进程的优先数或轮转时间片数、以及进程需要运行的时间片数,均由伪随机数发生器产生。 进程控制块结构如下:

PCB 进程标识数 链指针 优先数/轮转时间片数 占用CPU时间片数 进程所需时间片数 进程状态 进程控制块链结构如下: 其中:RUN—当前运行进程指针; HEAD—进程就绪链链首指针; TAID—进程就绪链链尾指针。 2.算法与框图 (1) 优先数法。 进程就绪链按优先数大小从高到低排列,链首进程首先投入运行。每过一个时间片,运行进程所需运行的时间片数减1,说明它已运行了一个时间片,优先数也减3,理由是该进程如果在一个时间片中完成不了,优先级应该降低一级。接着比较现行进程和就绪链链首进程的优先数,如果仍是现行进程高或者相同,就让现行进程继续进行,否则,调度就绪链链首进程投入运行。原运行进程再按其优先数大小插入就绪链,且改变它们对应的进程状态,直至所有进程都运行完各自的时间片数。 (2) 简单轮转法。 进程就绪链按各进程进入的先后次序排列,进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项(相当于优先数法的优先数记录项位置)。每过一个时间片,运行进程占用处理机的时间片数加1,然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等,若相等说明已到达轮转时间,应将现运行进程排到就绪链末尾,调度链首进程占用处理机,且改变它们的进程状态,直至所有进程完成各自的时间片。(3) 程序框图如下图所示。

操作系统实验报告--实验一--进程管理

实验一进程管理 一、目的 进程调度是处理机管理的核心内容。本实验要求编写和调试一个简单的进程调度程序。通过本实验加深理解有关进程控制块、进程队列的概念,并体会和了解进程调度算法的具体实施办法。 二、实验内容及要求 1、设计进程控制块PCB的结构(PCB结构通常包括以下信息:进程名(进程ID)、进程优先数、轮转时间片、进程所占用的CPU时间、进程的状态、当前队列指针等。可根据实验的不同,PCB结构的内容可以作适当的增删)。为了便于处理,程序中的某进程运行时间以时间片为单位计算。各进程的轮转时间数以及进程需运行的时间片数的初始值均由用户给定。 2、系统资源(r1…r w),共有w类,每类数目为r1…r w。随机产生n进程P i(id,s(j,k),t),0<=i<=n,0<=j<=m,0<=k<=dt为总运行时间,在运行过程中,会随机申请新的资源。 3、每个进程可有三个状态(即就绪状态W、运行状态R、等待或阻塞状态B),并假设初始状态为就绪状态。建立进程就绪队列。 4、编制进程调度算法:时间片轮转调度算法 本程序用该算法对n个进程进行调度,进程每执行一次,CPU时间片数加1,进程还需要的时间片数减1。在调度算法中,采用固定时间片(即:每执行一次进程,该进程的执行时间片数为已执行了1个单位),这时,CPU时间片数加1,进程还需要的时间片数减1,并排列到就绪队列的尾上。 三、实验环境 操作系统环境:Windows系统。 编程语言:C#。 四、实验思路和设计 1、程序流程图

2、主要程序代码 //PCB结构体 struct pcb { public int id; //进程ID public int ra; //所需资源A的数量 public int rb; //所需资源B的数量 public int rc; //所需资源C的数量 public int ntime; //所需的时间片个数 public int rtime; //已经运行的时间片个数 public char state; //进程状态,W(等待)、R(运行)、B(阻塞) //public int next; } ArrayList hready = new ArrayList(); ArrayList hblock = new ArrayList(); Random random = new Random(); //ArrayList p = new ArrayList(); int m, n, r, a,a1, b,b1, c,c1, h = 0, i = 1, time1Inteval;//m为要模拟的进程个数,n为初始化进程个数 //r为可随机产生的进程数(r=m-n) //a,b,c分别为A,B,C三类资源的总量 //i为进城计数,i=1…n //h为运行的时间片次数,time1Inteval为时间片大小(毫秒) //对进程进行初始化,建立就绪数组、阻塞数组。 public void input()//对进程进行初始化,建立就绪队列、阻塞队列 { m = int.Parse(textBox4.Text); n = int.Parse(textBox5.Text); a = int.Parse(textBox6.Text); b = int.Parse(textBox7.Text); c = int.Parse(textBox8.Text); a1 = a; b1 = b; c1 = c; r = m - n; time1Inteval = int.Parse(textBox9.Text); timer1.Interval = time1Inteval; for (i = 1; i <= n; i++) { pcb jincheng = new pcb(); jincheng.id = i; jincheng.ra = (random.Next(a) + 1); jincheng.rb = (random.Next(b) + 1); jincheng.rc = (random.Next(c) + 1); jincheng.ntime = (random.Next(1, 5)); jincheng.rtime = 0;

实验二 读者写者问题实验报告..

实验二读者写者问题实验报告 一、实验目的 Windows2000/XP提供了互斥量(mutex)、信号量(semapore)、事件(event)等三种同步对象和相应的系统调用,用于线程的互斥与同步。通过对读者写者问题的调试,了解Windows2000/XP中的同步机制。 二、实验内容及实验步骤 利用Windows2000/XP信号量机制,实现读者写者问题。 在Windows 2000环境下,创建一个控制台进程,此进程包含n个线程。用这n个线程来表示n个读者或写者。每个线程按相应测试数据文件(后面有介绍)的要求进行读写操作。用信号量机制分别实现读者优先和写者优先的读者-写者问题。 读者-写者问题的读写操作限制(包括读者优先和写者优先): 写-写互斥,即不能有两个写者同时进行写操作。 读-写互斥,即不能同时有一个线程在读,而另一个线程在写。 读-读允许,即可以有一个或多个读者在读。 读者优先的附加限制:如果一个读者申请进行读操作时已有另一个读者正在进行读操作,则该读者可直接开始读操作。 写者优先的附加限制:如果一个读者申请进行读操作时已有另一写者在等待访问共享资源,则该读者必须等到没有写者处于等待状态才能开始读操作。 运行结果显示要求:要求在每个线程创建、发出读写操作申请、开始读写操作和结果读写操作时分别显示一行提示信息,以确定所有处理都遵守相应的读写操作限制。 三、实验结果及分析 图2.1 选择界面 第一字段为一个正整数,表示线程序号。第二字段表示相应线程角色,R 表示读者是,W 表示写者。第三字段为一个正数,表示读写操作的开始时间。线程创建

后,延时相应时间(单位为秒)后发出对共享资源的读写申请。第四字段为一个正数,表示读写操作的持续时间。当线程读写申请成功后,开始对共享资源的读写操作,该操作持续相应时间后结束,并释放共享资源。下面是一个测试数据文件的例子: 1 R 3 5 2 W 4 5 3 R 5 2 4 R 6 5 5 W 5.1 3 测试结果如下: 图2.2 读者优先运行结果

山东大学操作系统实验报告4进程同步实验

山东大学操作系统实验报告4进程同步实验

计算机科学与技术学院实验报告 实验题目:实验四、进程同步实验学号: 日期:20120409 班级:计基地12 姓名: 实验目的: 加深对并发协作进程同步与互斥概念的理解,观察和体验并发进程同步与互斥 操作的效果,分析与研究经典进程同步与互斥问题的实际解决方案。了解 Linux 系统中 IPC 进程同步工具的用法,练习并发协作进程的同步与互斥操作的编程与调试技术。 实验内容: 抽烟者问题。假设一个系统中有三个抽烟者进程,每个抽烟者不断地卷烟并抽烟。抽烟者卷起并抽掉一颗烟需要有三种材料:烟草、纸和胶水。一个抽烟者有烟草,一个有纸,另一个有胶水。系统中还有两个供应者进程,它们无限地供应所有三种材料,但每次仅轮流提供三种材料中的两种。得到缺失的两种材料的抽烟者在卷起并抽掉一颗烟后会发信号通知供应者,让它继续提供另外的两种材料。这一过程重复进行。请用以上介绍的 IPC 同步机制编程,实现该问题要求的功能。 硬件环境: 处理器:Intel? Core?i3-2350M CPU @ 2.30GHz ×4 图形:Intel? Sandybridge Mobile x86/MMX/SSE2 内存:4G 操作系统:32位 磁盘:20.1 GB 软件环境: ubuntu13.04 实验步骤: (1)新建定义了producer和consumer共用的IPC函数原型和变量的ipc.h文件。

(2)新建ipc.c文件,编写producer和consumer 共用的IPC的具体相应函数。 (3)新建Producer文件,首先定义producer 的一些行为,利用系统调用,建立共享内存区域,设定其长度并获取共享内存的首地址。然后设定生产者互斥与同步的信号灯,并为他们设置相应的初值。当有生产者进程在运行而其他生产者请求时,相应的信号灯就会阻止他,当共享内存区域已满时,信号等也会提示生产者不能再往共享内存中放入内容。 (4)新建Consumer文件,定义consumer的一些行为,利用系统调用来创建共享内存区域,并设定他的长度并获取共享内存的首地址。然后设定消费者互斥与同步的信号灯,并为他们设置相应的初值。当有消费进程在运行而其他消费者请求时,相应的信号灯就会阻止它,当共享内存区域已空时,信号等也会提示生产者不能再从共享内存中取出相应的内容。 运行的消费者应该与相应的生产者对应起来,只有这样运行结果才会正确。

进程调度算法模拟实验

华北科技学院计算机系综合性实验 实验报告 课程名称操作系统C 实验学期2012至2013学年第2学期学生所在系部计算机系 年级专业班级 学生姓名学号 任课教师杜杏菁 实验成绩 计算机系制

《操作系统C》课程综合性实验报告 开课实验室:基础六机房2013年6月3日 实验题目进程调度算法模拟 一、实验目的 通过对进程调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度过程、调度算法的理解。 二、设备与环境 1.硬件设备:PC机一台 2.软件环境:安装Windows操作系统或者Linux操作系统,并安装相关的程序开发环境,如C \C++\Java等编程语言环境。 三、实验内容 (1)用C语言(或其它语言,如Java)实现对N个进程采用某种进程调度算法(如动态优先权调度)的调度。 (2)每个用来标识进程的进程控制块PCB可用结构来描述,包括以下字段: ?进程标识数ID。 ?进程优先数PRIORITY,并规定优先数越大的进程,其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时,ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进 入阻塞状态。 ?进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将 转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT,用来将PCB排成队列。 (3)优先数改变的原则: ?进程在就绪队列中呆一个时间片,优先数增加1。 ?进程每运行一个时间片,优先数减3。 (4)为了清楚地观察每个进程的调度过程,程序应将每个时间片内的进程的情况显示出来,包括正在运行的进程,处于就绪队列中的进程和处于阻塞队列中的进程。

操作系统实验报告(进程的创建)(DOC)

实验题目进程的创建小组合作否姓名班级学号 一、实验目的 1、了解进程的创建。 2、了解进程间的调用以及实现。 3、分析进程竞争资源的现象,学习解决互斥的方法。 4、加深对进程概念的理解,认识并发执行的本质。 二.实验环境 Windows 系统的计算机一台,安装了Linux虚拟机 三、实验内容与步骤 1、fork()系统调用的使用例子 程序代码: #include #include #include int glob=3; int main(void) { pid_t pid;int loc=3; printf("before fork();glod=%d,loc=%d.\n",glob,loc); if((pid=fork())<0) { printf("fork() error. \n"); exit(0); } else if(pid==0) { glob++; loc--; printf("child process changes glob and loc: \n"); } else

wait(0); printf("parent process doesn't change the glob and loc:\n"); printf("glob=%d,loc=%d\n",glob,loc); exit(0); } 运行结果: 2、理解vofork()调用: 程序代码: #include #include #include int glob=3; int main(void) { pid_t pid; int loc=3; if((pid=vfork())<0) { printf("vfork() error\n"); exit(0); } else if(pid==0) { glob++; loc--; printf("child process changes the glob and loc\n"); exit(0); } else printf ("parent process doesn't change the glob and loc\n"); printf("glob=%d,val=%d\n",glob,loc);

操作系统读者写者实验报告

《操作系统》上机实验报告 实验项目读者写者 学院(部)信息学院 专业计算机科学与技术班级 学生姓名 学号

读者写者问题 一.实验目的: 1.熟悉读者优先和写者优先的过程。 2.更好地理解进程同步的概念及其实现方法。 二.实验要求: 分别实现读者优先和写者优先。 “读-写”互斥,即不能同时有一个读者在读,同时去有一个写者在写; “写-写”互斥,即不能有两个写者同时进行写操作; “读-读”允许,即可以有两个以上的读者同时进行读操作。 三.实验内容: 读者优先: 如果没有写者正在操作,则读者不需要等待,用一个整型变量readcount 记录当前的读者数目,用于确定是否释放写者线程,(当readcout=0 时,说明所有的读者都已经读完,释放一个写者线程),每个读者开始读之前都要修改readcount,为了互斥的实现对readcount 的修改,需要一个互斥对象Mutex来实现互斥。 另外,为了实现写-写互斥,需要一个临界区对象write,当写者发出写的请求时,必须先得到临界区对象的所有权。通过这种方法,可以实现读写互斥,当readcount=1 时,(即第一个读者的到来时,),读者线程也必须申请临界区对象的所有权. 当读者拥有临界区的所有权,写者都阻塞在临界区对象write上。当写者拥有临界区对象所有权时,第一个判断完readcount==1 后,其余的读者由于等待对readcount的判断,阻塞在Mutex上! 写者优先: 写者优先和读者优先有相同之处,不同的地方在:一旦有一个写者到来时,应该尽快让写者进行写,如果有一个写者在等待,则新到的读者操作不能读操作,为此添加一个整型变量writecount,记录写者的数目,当writecount=0时才可以释放读者进行读操作!为了实现对全局变量writecount的互斥访问,设置了一个互斥对象Mutex3。 为了实现写者优先,设置一个临界区对象read,当有写者在写或等待时,读者必须阻塞在临界区对象read上。 读者除了要一个全局变量readcount实现操作上的互斥外,还需要一个互斥对象对阻塞在read这一个过程实现互斥,这两个互斥对象分别为mutex1和mutex2。

进程的同步实验报告

操作系统 实验报告 哈尔滨工程大学 计算机科学与技术学院

一、实验概述 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.更加深入的了解读者写者问题的算法; 2.加深对线程,进程的理解; 3.加深对“线程同步”概念的理解,理解并应用“信号量机制”; 4.熟悉计算机对处理机的管理,了解临界资源的访问方式; 5.了解C++中线程的实现方式,研读API。 (二)课程设计的任务 多进程/线程编程:读者-写者问题。 ●设置两类进程/线程,一类为读者,一类为写者; ●随机启动读者或写者; ●显示读者或写者执行状态; ●随着进程/线程的执行,更新显示; (三)相关原理及算法描述; 整体概况: 该程序从大体上来分只有两个模块,即“读者优先”和“写者优先”模块. 读者优先: 如果没有写者正在操作,则读者不需要等待,用一个整型变量readcount记录读者数目,用于确定是否释放读者线程,readcount的初值为0.当线程开始调入时. 每个读者准备读. 等待互斥信号,保证对readcount 的访问,修改互斥.即readcount++. 而当读者线程进行读操作时,则读者数目减少(readcount--).当readcout=0 时,说明所 有的读者都已经读完,离开临界区唤醒写者(LeaveCriticalSection(&RP_Write);), 释 放互斥信号(ReleaseMutex(h_Mutex)). 还需要一个互斥对象mutex来实现对全局变量Read_count修改时的互斥. 另外,为了实现写-写互斥,需要增加一个临界区对象Write。当写者发出写请求时, 必须申请临界区对象的所有权。通过这种方法,可以实现读-写互斥,当 Read_count=1时(即第一个读者到来时),读者线程也必须申请临界区对象的所有 权 写者优先: 写者优先与读者不同之处在于一旦一个写者到来,它应该尽快对文件进行写操作,如果有一个写者在等待,则新到来的读者不允许进行读操作。为此应当填加 一个整形变量write_count,用于记录正在等待的写者的数目,write_count的初值 为0.当线程开始调入时.只允许一个写者准备读. 等待互斥信号,保证对write_count 的访问,修改互斥.即write_count++.而当写者线程进行读操作时,则相应写者数目减 少(write_count--).当write_count=0 时,说明所有的读者都已经读完,离开临界区唤 醒读者,释放互斥信号. 为了实现写者优先,应当填加一个临界区对象read,当有写者在写文件或等待时,读者必须阻塞在read上。

李建伟版实用操作系统第二版最新习题 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、答:

实验一处理器调度实验报告

处理器调度一、实验内容 选择一个调度算法,实现处理器调度。 二、实验目的 在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。 当就绪状态进程 个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下处理器调度,帮助学生加深了解处理器调度的工作。 三、实验题目 设计一个按优先数调度算法实现处理器调度的程序 提示: (1)假定系统有五个进程,每一个进程用一个进程控制块PCB来代表。进 程控制块的格 式为: 其中,进程名----作为进程的标识,假设五个进程的进程名分别是R, P2, P3, P4,R。 指针—按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块

首地址,最后一个进程中的指针为“ 0”。 要求运行时间-- 假设进程需要运行的单位时间数。 优先数-赋予进程的优先数,调度时总是选取优先数大的进程先执行。 状态-可假设有两种状态,“就绪”状态和“结束“状态,五个进程的初 始状态都为 “就绪“状态,用“ R”表示,当一个进程运行结束后,它的状态变为“结束”, 用“ E”表示。 (2)在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数” 和“要求运行时间”。 (3)为了调度方便,把五个进程按给定的优先数从大到小连成队列,用一单元指出队首 进程,用指针指出队列的连接情况。例: 队首标志 (4)处理器调度总是选队首进程运行。采用动态改变优先数的办法,进程每运行一次优 先数就减“ 1”。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的 启动运行,而是执行: 优先数- 1 要求运行时间-1 来模拟进程的一次运行提醒注意的是:在实际的系统中,当一个进程被选中运

进程间通信实验报告

进程间通信实验报告 班级: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.这一点有助于理解消息转送的实现机理。

读者写者问题

一设计概述 所谓读者写者问题,是指保证一个writer进程必须与其他进程互斥地访问共享对象的同步问题。 读者写者问题可以这样的描述,有一群写者和一群读者,写者在写同一本书,读者也在读这本书,多个读者可以同时读这本书,但是,只能有一个写者在写书,并且,读者必写者优先,也就是说,读者和写者同时提出请求时,读者优先。当读者提出请求时需要有一个互斥操作,另外,需要有一个信号量S来当前是否可操作。 信号量机制是支持多道程序的并发操作系统设计中解决资源共享时进程间的同步与互斥的重要机制,而读者写者问题则是这一机制的一个经典范例。 与记录型信号量解决读者—写者问题不同,信号量机制它增加了一个限制,即最多允许RN个读者同时读。为此,又引入了一个信号量L,并赋予初值为RN,通过执行wait(L,1,1)操作,来控制读者的数目,每当有一个读者进入时,就要执行wait(L,1,1)操作,使L的值减1。当有RN个读者进入读后,L便减为0,第RN+1 个读者要进入读时,必然会因wait(L,1,1)操作失败而堵塞。对利用信号量来解决读者—写者问题的描述如下: Var RN integer;L,mx:semaphore: =RN,1; Begin Parbegin Reader :begin Repeat Swait(L,1,1); Swait(mx,1,0); . Perform reader operation; Ssignal(L,1); Until false; End

Writer :begin Repeat Swait(mx ,1,1,l,RN,0); Perform writer operation; Ssignal(mx,1); Until false; End Parend End 其中,Swait(mx,1,0)语句起着开关作用,只要无Writer进程进入些,mx=1,reader进程就都可以进入读。但是要一旦有Writer进程进入写时,其MX=0,则任何reader进程就都无法进入读。Swait(mx ,1,1,l,RN,0)语句表示仅当既无Write 进程在写(mx=1),又无reader进程在读(L=RN)时,writer进程才能进入临界区写。 本设计方案就是通过利用记录型信号量对读者写者问题的解决过程进行模拟演示,形象地阐述记录型信号量机制的工作原理。 二设计目的与内容 一实验目的 l. 用信号量来实现读者写者问题。 2. 理解和运用信号量、PV原语、进程间的同步互斥关系等基本知识。二、二实验内容 读者写者问题的定义如下:有一个许多进程共享的数据区,这个数据区可以是一个文件或者主存的一块空间;有一些只读取这个数据区的进程(Reader)和一些只往数据区写数据的进程(Writer),此外还需要满足以下条件:(1)任意多个读进程可以同时读这个文件; (2)一次只有一个写进程可以往文件中写; (3)如果一个写进程正在进行操作,禁止任何读进程度文件。

相关主题