操作系统课程设计-Windows 线程的互斥和同步

望525

已于 2024-03-01 15:58:35 修改

阅读量1.1k

点赞数 22

分类专栏：操作系统文章标签： windows

于 2024-01-17 23:23:32 首次发布

本文链接：https://blog.csdn.net/qq_63306482/article/details/135661589

版权

操作系统专栏收录该内容

10 篇文章 3 订阅

订阅专栏

前言

本实验为课设内容，博客内容为部分报告内容，仅为大家提供参考，请勿直接抄袭，另外，本次实验所用平台是dev c++5.11

1 实验题目

实验四 Windows线程的互斥和同步

2 实验目的

(1) 回顾操作系统进程、线程的有关概念，加深对 Windows 线程的理解。
(2) 了解互斥体对象，利用互斥与同步操作编写生产者-消费者问题的并发程序，加深对 P (即semWait)、V(即 semSignal)原语以及利用 P、V 原语进行进程间同步与互斥操作的理解。

3 实验内容

3.1 步骤

（1）步骤1：打开Dev-C++5.11 新建一个文件，命名为实验4，并保存为cpp文件。

（2）步骤2：将清单5-1的源代码复制到实验4.cpp文件中，并点击编译按钮将其编译成可执行文件，再进入到保存文件的目录下，右键，选择在终端打开，运行编译好的可执行文件，观察运行结果。

（3）步骤3：阅读源程序，找出创建线程的WindowsAPI函数，及其执行的第一个函数。

（4）步骤4：调整生产者和消费者线程的数量，观察运行结果。

（5）步骤5：按清单5-1代码中的注释修改内容，观察运行结果。

（6）步骤 6：根据步骤 4 的结果，并查看 MSDN，回答下列问题：

1）CreateMutex 中有几个参数，各代表什么含义。

2）CreateSemaphore 中有几个参数，各代表什么含义，信号量的初值在第几个参数中。

3）程序中 P、V 原语所对应的实际 Windows API 函数是什么，写出这几条语句。

4）CreateMutex 能用 CreateSemaphore 替代吗？尝试修改程序 5-1，将信号量 Mutex 完全用 CreateSemaphore 及相关函数实现。写出要修改的语句。

3.2 关键代码

3.2.1 创建生产者和消费者进程

//创建生产者线程
	for (int i=0; i<PRODUCERS_COUNT; ++i) {
		hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);
		if (hThreads[i]==NULL) return -1;
	}
//创建消费者线程
	for (int i=0; i<CONSUMERS_COUNT; ++i) {
	hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);
		if (hThreads[i]==NULL) return -1;
	}

3.2.2 生产者和消费者进程

//生产者
DWORD WINAPI Producer(LPVOID lpPara) {
	while(p_ccontinue) {
		WaitForSingleObject(EmptySemaphore,INFINITE); //p(empty);
		WaitForSingleObject(Mutex,INFINITE); //p(mutex);
		Produce();
		Append();
		Sleep(1500);
		ReleaseMutex(Mutex); //V(mutex);
		ReleaseSemaphore(FullSemaphore,1,NULL); //V(full);
	}
	return 0;
}
//消费者
DWORD WINAPI Consumer(LPVOID lpPara) {
	while(p_ccontinue) {
		WaitForSingleObject(FullSemaphore,INFINITE);//P(full);
		WaitForSingleObject(Mutex,INFINITE); //P(mutex);
		Take();
		Consume();
		Sleep(1500);
		ReleaseMutex(Mutex); //V(mutex);
		ReleaseSemaphore(EmptySemaphore,1,NULL); //V(empty);
	}
	return 0;
}

4 实验结果与分析

（1）执行步骤2后的部分结果如下图所示：

图1.1 生产者和消费者的部分运行结果

（2）步骤3中，线程的第一个执行函数是Producer或Consumer函数，他们是创建线程API函数的第3个参数。

（3）执行步骤4后，当消费者数量大于生产者数量时，可以在控制台看到消费者会经常因为资源不足而等待生产者，其结果如下图所示：

图1.2 调整生产者和消费者数量后的部分结果

（4）执行步骤5后，会看到控制台没有输出，因为这时候生产者可用的缓冲区数量为0，消费者的可用的初始产品数量为0，导致程序进入循环等待状态，无法继续执行下去，结果如下图所示：

图1.3 按注释修改后的控制台输出结果

（5）步骤6相关问题：

1）CreateMutex中有3个参数，各参数的含义是：

LPSECURITY_ATTRIBUTES lpMutexAttributes, // 指向安全属性的指

BOOL bInitialOwner, // 初始化互斥对象的所有者，如果希望进程立即拥有互斥体则设为FALSE

LPCTSTR lpName // 指向互斥对象名的指针

2）CreateSemaphore中有四个参数，各参数的含义是：LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,//指向 SECURITY_ATTRIBUTES 结构的指针。如果此参数为 NULL，则子进程无法继承句柄。

LONG lInitialCount,//信号灯对象的初始计数。此值必须大于或等于零，并且小于或等于 lMaximumCount。

LONG lMaximumCount,//信号量对象的最大计数。此值必须大于零。

LPCSTR lpName//信号灯对象的名称。名称限制为 MAX_PATH 个字符。名称比较区分大小写。

3）P对应WaitForSingleObject(EmptySemaphore,INFINITE)和WaitForSingleObject(Mutex,INFINITE)，V对应ReleaseMutex(Mutex)和ReleaseSemaphore(FullSemaphore,1,NULL)。

4）可以，需要修改的代码是：将Mutex = CreateMutex(NULL,FALSE,NULL)改为Mutex = CreateSemaphore(NULL,1,1,NULL)，将ReleaseMutex(Mutex)改为ReleaseSemaphore(Mutex,1,NULL)。

5 代码

注意，代码是按照步骤6修改之后的

#include <windows.h>
#include <iostream>
const unsigned short SIZE_OF_BUFFER = 2; //缓冲区长度
unsigned short ProductID = 0; //产品号
unsigned short ConsumeID = 0; //将被消耗的产品号
unsigned short in = 0; //产品进缓冲区时的缓冲区下标
unsigned short out = 0; //产品出缓冲区时的缓冲区下标
int buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列
bool p_ccontinue = true; //控制程序结束
HANDLE Mutex; //用于线程间的互斥
HANDLE FullSemaphore; //当缓冲区满时迫使生产者等待
HANDLE EmptySemaphore; //当缓冲区空时迫使消费者等待
DWORD WINAPI Producer(LPVOID); //生产者线程
DWORD WINAPI Consumer(LPVOID); //消费者线程
int main() {
//创建各个互斥信号
//注意，互斥信号量和同步信号量的定义方法不同，互斥信号量调用的是 CreateMutex 函数，
//同步信号量调用的是 CreateSemaphore 函数，函数的返回值都是句柄。
	//Mutex = CreateMutex(NULL,FALSE,NULL);
	Mutex = CreateSemaphore(NULL,1,1,NULL);
	//第一个参数的SIZE_OF_BUFFER含义应该是有SIZE_OF_BUFFER个可供消费的产品
	//第二个SIZE_OF_BUFFER的含义应该是大小
	EmptySemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER,SIZE_OF_BUFFER,NULL);
	//将上句做如下修改，看看结果会怎样，会不输出
	//EmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);
	//参数的0含义应该是有0个可供消费的产品，第二个SIZE_OF_BUFFER的含义应该是大小
	FullSemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER,NULL);
//调整下面的数值，可以发现，当生产者个数多于消费者个数时，
//生产速度快，生产者经常等待消费者；反之，消费者经常等待
	const unsigned short PRODUCERS_COUNT = 3; //生产者的个数
	const unsigned short CONSUMERS_COUNT = 1; //消费者的个数
//总的线程数
	const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;
	HANDLE hThreads[THREADS_COUNT]; //各线程的 handle
	DWORD producerID[PRODUCERS_COUNT]; //生产者线程的标识符
	DWORD consumerID[CONSUMERS_COUNT]; //消费者线程的标识符
//创建生产者线程
	for (int i=0; i<PRODUCERS_COUNT; ++i) {
		hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);
		if (hThreads[i]==NULL) return -1;
	}
//创建消费者线程
	for (int i=0; i<CONSUMERS_COUNT; ++i) {

		hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);
		if (hThreads[i]==NULL) return -1;
	}
	while(p_ccontinue) {
		if(getchar()) { //按回车后终止程序运行
			p_ccontinue = false;
		}
	}
	return 0;
}
//生产一个产品。简单模拟了一下，仅输出新产品的 ID 号
void Produce() {
	std::cout << std::endl<< "Producing " << ++ProductID << " ... ";
	std::cout << "Succeed" << std::endl;
}
//把新生产的产品放入缓冲区
void Append() {
	std::cerr << "Appending a product ... ";
	buffer[in] = ProductID;
	in = (in+1)%SIZE_OF_BUFFER;
	std::cerr << "Succeed" << std::endl;
//输出缓冲区当前的状态
	for (int i=0; i<SIZE_OF_BUFFER; ++i) {
		std::cout << i <<": " << buffer[i];
		if (i==in) std::cout << " <-- 生产";//生产者优先
		if (i==out) std::cout << " <-- 消费";
		std::cout << std::endl;
	}
}
//从缓冲区中取出一个产品
void Take() {
	std::cerr << "Taking a product ... ";
	ConsumeID = buffer[out];
	buffer[out] = 0;
	out = (out+1)%SIZE_OF_BUFFER;
	std::cerr << "Succeed" << std::endl;
//输出缓冲区当前的状态
	for (int i=0; i<SIZE_OF_BUFFER; ++i) {
		std::cout << i <<": " << buffer[i];
		if (i==in) std::cout << " <-- 生产";//生产者优先
		if (i==out) std::cout << " <-- 消费";
		std::cout << std::endl;
	}
}
//消耗一个产品
void Consume() {
	std::cout << "Consuming " << ConsumeID << " ... ";
	std::cout << "Succeed" << std::endl;
}
//生产者
DWORD WINAPI Producer(LPVOID lpPara) {
	while(p_ccontinue) {
		WaitForSingleObject(EmptySemaphore,INFINITE); //p(empty);
		WaitForSingleObject(Mutex,INFINITE); //p(mutex);
		Produce();
		Append();
		Sleep(1500);
		//ReleaseMutex(Mutex); //V(mutex);
		ReleaseSemaphore(Mutex,1,NULL); //V(full);
		ReleaseSemaphore(FullSemaphore,1,NULL); //V(full);
	}
	return 0;
}
//消费者
DWORD WINAPI Consumer(LPVOID lpPara) {
	while(p_ccontinue) {
		WaitForSingleObject(FullSemaphore,INFINITE);//P(full);
		WaitForSingleObject(Mutex,INFINITE); //P(mutex);
		Take();
		Consume();
		Sleep(1500);
		//ReleaseMutex(Mutex); //V(mutex);
		ReleaseSemaphore(Mutex,1,NULL); //V(full);
		ReleaseSemaphore(EmptySemaphore,1,NULL); //V(empty);
	}
	return 0;
}