哈尔滨工程大学操作系统(第五讲—进程的同步)

操作系统

实验报告

哈尔滨工程大学

计算机科学与技术学院

一、实验概述

1. 实验名称

进程的同步

2. 实验目的

（1）使用EOS的信号量，编程解决生产者—消费者问题，理解进程同步的意义。

（2）调试跟踪EOS 信号量的工作过程，理解进程同步的原理。

（3）修改EOS 的信号量算法，使之支持等待超时唤醒功能（有限等待），加深理解进程同步的原理

3. 实验类型

验证+设计

4. 实验内容

（1）准备实验

（2）使用EOS的信号量解决生产者－消费者问题

（3）调试EOS信号量的工作过程

（4）修改EOS的信号量算法

二、实验环境

WINDOWS XP，OS LAB。

三、实验过程

1. 设计思路和流程图

2.算法实现

if (Semaphore->Count>0){

Semaphore->Count--;

flag=STATUS_SUCCESS;

}//如果信号量大于零，说明尚有资源，可以为线程分配

else

flag=PspWait(&Semaphore->WaitListHead, Milliseconds);

KeEnableInterrupts(IntState); //

原子操作完成，恢复中断。

return flag;

}//否则，说明资源数量不够，不能再为线程分配资源，因此使线程等待if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) {

Status = STATUS_SEMAPHORE_LIMIT_EXCEEDED;

} else {

//记录当前的信号量的值。

if (NULL != PreviousCount) {

*PreviousCount = Semaphore->Count;

} int mm=Semaphore->Count;

//目前仅实现了标准记录型信号量，每执行一次信号量的释放操作

// 只能使信号量的值增加1.

while ((!ListIsEmpty(&Semaphore->WaitListHead))&&(ReleaseCount)){

PspWakeThread(&Semaphore->WaitListHead, STATUS_SUCCESS);

PspThreadSchedule();

ReleaseCount--;

} Semaphore->Count=mm+ReleaseCount;

// 可能有线程被唤醒，执行线程调度。

Status = STATUS_SUCCESS; }

3.需要解决的问题及解答

（1）生产者在生产了13 号产品后本来要继续生产14 号产品，可此时生产者为什么必须等待消费者消费了4号产品后，才能生产14号产品呢？生产者和消费者是怎样使用同步对象来实现该同步过程的呢？

答：因为此时生产了从0到13的14个产品，但是只消费了从0到3的4个产品，所以缓冲池中的10个缓冲区就都被占用了，所以必须等待消费者消费了4号产品后，才能生产14号产品。Mutex对象是用来保护临界资源的，防止生产者线程和消费者线程同时访问临界资源，从而造成混乱。Empty信号量和Full信号量是相互合作不可分割的，在生产者线程中，Empty信号量保证在没有空缓冲区的时候让生产者停止生产，

Full信号量保证在生产完毕一个产品后增加一个满缓冲区；在消费者线程中，Full信号量保证在没有满缓冲区的时候让消费者停止消费，Empty信号量保证在消费完毕一个产品后增加一个空缓冲区。

（2）绘制ps/semaphore.c文件内PsWaitForSemaphore 和PsReleaseSemaphore 函数的流程图。

（3）思考在ps/semaphore.c文件内的PsWaitForSemaphore和PsReleaseSemaphore

函数中，为什么要使用原子操作？

答：在执行PsWaitForSemaphore和PsReleaseSemaphore函数的时候，不允许cpu响应外部中断，如果此时cpu响应了外部中断，会产生不可预料的结果，无法正常完成函数的功能。

4. 主要数据结构、实现代码及其说明

将Producer函数中等待Empty信号量的代码行

WaitForSingleObject(EmptySemaphoreHandle, INFINITE); 替换为

while(WAIT_TIMEOUT == WaitForSingleObject(EmptySemaphoreHandle, 300)){ printf("Producer wait for empty semaphore timeout\n"); } 将Consumer函数中等待Full信号量的代码行

WaitForSingleObject(FullSemaphoreHandle, INFINITE); 替换为

while(WAIT_TIMEOUT == WaitForSingleObject(FullSemaphoreHandle, 300)){ printf("Consumer wait for full semaphore timeout\n"); }

5.源程序并附上注释

（1）EOS的信号量算法，一次消费1个产品的。

#include "psp.h"

VOID PsInitializeSemaphore(

IN PSEMAPHORE Semaphore,

IN LONG InitialCount,

IN LONG MaximumCount

)

{ASSERT(InitialCount >= 0 && InitialCount <= MaximumCount && MaximumCount > 0);

Semaphore->Count = InitialCount;

Semaphore->MaximumCount = MaximumCount;

ListInitializeHead(&Semaphore->WaitListHead);

}

STATUS

PsWaitForSemaphore(

IN PSEMAPHORE Semaphore,

IN ULONG Milliseconds

)

/*++

功能描述：

信号量的Wait 操作（P 操作）。

参数：

Semaphore -- Wait 操作的信号量对象。

Milliseconds -- 等待超时上限，单位毫秒。

返回值：

STATUS_SUCCESS。

当你修改信号量使之支持超时唤醒功能后，如果等待超时，应该返

回STATUS_TIMEOUT。

--*/

{

BOOL IntState;

STATUS flag;

ASSERT(KeGetIntNesting() == 0); // 中断环境下不能调用此函数。

IntState = KeEnableInterrupts(FALSE); // 开始原子操作，禁止中断。

//

// 目前仅实现了标准记录型信号量，不支持超时唤醒功能，所以PspWait 函数

// 的第二个参数的值只能是INFINITE。

//

if (Semaphore->Count>0){

Semaphore->Count--;

flag=STATUS_SUCCESS;

}//如果信号量大于零，说明尚有资源，可以为线程分配

else

flag=PspWait(&Semaphore->WaitListHead, Milliseconds);

KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。

return flag;

}//否则，说明资源数量不够，不能再为线程分配资源，因此要使线程等待

KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。

return STATUS_SUCCESS;

}

STATUS

PsReleaseSemaphore(

IN PSEMAPHORE Semaphore,

IN LONG ReleaseCount,

OUT PLONG PreviousCount

)

/*++

功能描述：

信号量的Signal 操作（V 操作）。

参数：

Semaphore -- Wait 操作的信号量对象。

ReleaseCount -- 信号量计数增加的数量。当前只能为1。当你修改信号量使之支持超时唤醒功能后，此参数的值能够大于等于1。PreviousCount -- 返回信号量计数在增加之前的值。

返回值：

如果成功释放信号量，返回STATUS_SUCCESS。

--*/

{

STATUS Status;

BOOL IntState;

IntState = KeEnableInterrupts(FALSE); // 开始原子操作，禁止中断。

if (Semaphore->Count + ReleaseCount > Semaphore->MaximumCount) {

Status = STATUS_SEMAPHORE_LIMIT_EXCEEDED;

}

else {

//记录当前的信号量的值。

if (NULL != PreviousCount) {

*PreviousCount = Semaphore->Count;

}

int mm=Semaphore->Count;

// 目前仅实现了标准记录型信号量，每执行一次信号量的释放操作

// 只能使信号量的值增加1。

while

((!ListIsEmpty(&Semaphore->WaitListHead))&&(ReleaseCount)){

PspWakeThread(&Semaphore->WaitListHead,

STATUS_SUCCESS);

PspThreadSchedule();

ReleaseCount--;

}

Semaphore->Count=mm+ReleaseCount;

// 可能有线程被唤醒，执行线程调度。

Status = STATUS_SUCCESS;

}

KeEnableInterrupts(IntState); // 原子操作完成，恢复中断。

return Status;

}

//////////////////////////////////////////////////////////////////////////

// 下面是和信号量对象类型相关的代码。

// 信号量对象类型指针。

POBJECT_TYPE PspSemaphoreType = NULL;

// 用于初始化semaphore 结构体的参数结构体。

typedef struct _SEM_CREATE_PARAM{

LONG InitialCount;

LONG MaximumCount;

}SEM_CREATE_PARAM, *PSEM_CREATE_PARAM;

// semaphore 对象的构造函数，在创建新semaphore 对象时被调用。

VOID

PspOnCreateSemaphoreObject(

IN PVOID SemaphoreObject,

IN ULONG_PTR CreateParam

)

{

PsInitializeSemaphore( (PSEMAPHORE)SemaphoreObject,

((PSEM_CREATE_PARAM)CreateParam)->InitialCount,

((PSEM_CREATE_PARAM)CreateParam)->MaximumCount );

}

// semaphore 对象类型的初始化函数。

VOID

PspCreateSemaphoreObjectType(

VOID

)

{

STATUS Status;

OBJECT_TYPE_INITIALIZER Initializer;

Initializer.Create = PspOnCreateSemaphoreObject;

Initializer.Delete = NULL;

Initializer.Wait = (OB_WAIT_METHOD)PsWaitForSemaphore;

Initializer.Read = NULL;

Initializer.Write = NULL;

Status = ObCreateObjectType("SEMAPHORE", &Initializer,

&PspSemaphoreType);

if (!EOS_SUCCESS(Status)) {

KeBugCheck("Failed to create semaphore object type!");

}

}

// semaphore 对象的构造函数。

STATUS

PsCreateSemaphoreObject(

IN LONG InitialCount,

IN LONG MaximumCount,

IN PSTR Name,

OUT PHANDLE SemaphoreHandle

)

{

STATUS Status;

PVOID SemaphoreObject;

SEM_CREATE_PARAM CreateParam;

if(InitialCount < 0 || MaximumCount <= 0 || InitialCount > MaximumCount){

return STATUS_INV ALID_PARAMETER;

}

//创建信号量对象。

CreateParam.InitialCount = InitialCount;

CreateParam.MaximumCount = MaximumCount;

Status = ObCreateObject( PspSemaphoreType,

Name,

sizeof(SEMAPHORE),

(ULONG_PTR)&CreateParam,

&SemaphoreObject);

if (!EOS_SUCCESS(Status)) {

return Status;

}

Status = ObCreateHandle(SemaphoreObject, SemaphoreHandle);

if (!EOS_SUCCESS(Status)) {

ObDerefObject(SemaphoreObject);

}

return Status;

}

// semaphore 对象的signal 操作函数。

STATUS

PsReleaseSemaphoreObject(

IN HANDLE Handle,

IN LONG ReleaseCount,

IN PLONG PreviousCount

)

{

STATUS Status;

PSEMAPHORE Semaphore;

if (ReleaseCount < 1) {

return STATUS_INV ALID_PARAMETER;

}

// 由semaphore 句柄得到semaphore 对象的指针。

Status = ObRefObjectByHandle(Handle, PspSemaphoreType, (PVOID*)&Semaphore);

if (EOS_SUCCESS(Status)) {

Status = PsReleaseSemaphore(Semaphore, ReleaseCount, PreviousCount);

ObDerefObject(Semaphore);

}

return Status;

}

6.程序运行时的初值和运行结果

（1）此次执行并没有进行等待，只是将Empty信号量的计数减少了1（由10变为了9）就返回了。

此次执行没有唤醒其它线程（因为此时没有线程在Full信号量上被阻塞），只是将Full信号量的计数增加了1（由0变为了1）。

等待信号量中，在“调用堆栈”窗口中双击PsWaitForSemaphore函数的堆栈帧，查看Empty 信号量计数（Semaphore->Count）的值为-1。

释放信号量中，查看Consumer函数中变量i的值为4，说明已经消费了4号产品。

Empty信号量计数的值已经由-1增加为了0

测试结果

(2)一次消费2个产品

代码

// 消费者线程函数。

ULONG Consumer(PVOID Param)

{

int i;

int OutIndex = 0;

for (i = 0; i < PRODUCT_COUNT; i += 2) {

while(WAIT_TIMEOUT == WaitForSingleObject(FullSemaphoreHandle, 300)){

printf("Consumer wait for full semaphore timeout\n");

}

while(WAIT_TIMEOUT == WaitForSingleObject(FullSemaphoreHandle, 300)){

printf("Consumer wait for full semaphore timeout\n");

}

WaitForSingleObject(MutexHandle, INFINITE);

printf("\t\t\tConsume a %d\n", Buffer[OutIndex]);

OutIndex = (OutIndex + 1) % BUFFER_SIZE;

printf("\t\t\tConsume a %d\n", Buffer[OutIndex]);

OutIndex = (OutIndex + 1) % BUFFER_SIZE;

ReleaseMutex(MutexHandle);

ReleaseSemaphore(EmptySemaphoreHandle, 2, NULL);

// 休息一会儿。让前 14 个数的消费速度比较慢，后面的较快。

if (i < 14) {

Sleep(2000);

} else {

Sleep(100);

}

}

return 0;

}

四、实验体会

通过本次实验，我对进程同步算法有了更深的理解，对消费者-生产者模型也有了更深的认识，留下了很深的印象。这次实验过程中我遇到了不少问题，但通过老师的讲解和同学的帮助都得以解决，收获很大，本次实验也提高了我的实际动手能力，体会到了进程同步算法的实质与学习的乐趣。