一、实验题目
进程(线程)的同步与互斥
二、实验目的
1． 掌握基本的同步与互斥算法，理解生产者消费者模型。
2． 学习使用Windows中基本的同步对象，掌握相关API的使用方法。
3． 了解Windows中多线程的并发执行机制，实现进程的同步与互斥。
三、实验内容与要求
1． 实验内容
以生产者/消费者模型为依据，在Windows 环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。
2． 实验要求
学习并理解生产者/消费者模型及其同步/互斥规则；
学习了解Windows同步对象及其特性；
熟悉实验环境，掌握相关API的使用方法；
设计程序，实现生产者/消费者进程(线程)的同步与互斥；
四、算法描述（含数据结构定义）或流程图
我们利用Windows SDK提供的API编程实现实验题目要求，而VC中包含有Windows SDK的所有工具和定义。要使用这些API，需要包含 对这些函数进行说明的SDK头文件——最常见的是Windows.h(特殊的API调用还需要包含其他头文件)。
下面给出的是本实验使用到的API的功能和使用方法简单介绍。
(1) CreateThread
功能——创建一个在调用进程的地址空间中执行的线程
格式
HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParamiter,
DWORD dwCreationFlags,
Lpdword lpThread );
参数说明
lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。
dwStackSize——定义原始堆栈大小。
lpStartAddress——指向使用LPTHRAED_START_ROUTINE类型定义的函数。
lpParamiter——定义一个给进程传递参数的指针。
dwCreationFlags——定义控制线程创建的附加标志。
lpThread——保存线程标志符(32位)
(2) CreateMutex
功能——创建一个命名或匿名的互斥量对象
格式
HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCTSTR lpName);
参数说明
lpMutexAttributes——必须取值NULL。
bInitialOwner——指示当前线程是否马上拥有该互斥量(即马上加锁)。
lpName——互斥量名称。
(3) CreateSemaphore
功能——创建一个命名或匿名的信号量对象
格式
HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPCTSTR lpName );
参数说明
lpSemaphoreAttributes——必须取值NULL。
lInitialCount——信号量的初始值。该值大于等于0，但小于等于lMaximumCount指定的最大值。
lMaximumCount——信号量的最大值。
lpName——信号量名称。
(4) WaitForSingleObject
功能——使程序处于等待状态，直到信号量hHandle出现(即其值大于0)或超过规定的等待时间
格式
DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
参数说明
hHandle——信号量指针。
dwMilliseconds——等待的最长时间(INFINITE为无限等待)。
(5) ReleaseSemaphore
功能——对指定信号量加上一个指定大小的量。成功执行则返回非0值
格式
BOOL ReleaseSemaphore(HANDLE hSemaphore,
LONG lReleaseCount,
LPLONG lppreviousCount );
参数说明
hSemaphore——信号量指针。
lReleaseCount——信号量的增量。
lppreviousCount——保存信号量当前值。
(6) ReleaseMutex
功能——打开互斥锁，即把互斥量加1。成功调用则返回0
格式
BOOL ReleaseMutex(HANDLE hMutex);
参数说明
hMutex——互斥量指针。
五、实验过程
#include <windows.h>
#include <iostream>
using namespace std;
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#define MAX_THREAD_NUM 64 //最大线程数
#define INTE_PER_SEC 1000 //延迟时间的毫秒值
const int SIZE_OF_BUFFER = 10; //缓冲区长度
int ProductID = 0; //产品号
int ConsumeID = 0; //将被消耗的产品号
int in = 0; //产品进缓冲区时的缓冲区下标
int out = 0; //产品出缓冲区时的缓冲区下标
bool running=true; //判断程序能否继续执行的逻辑值
int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列
HANDLE g_hMutex; //公有信号量，用于线程间的互斥
HANDLE g_hFullSemaphore; //生产者的私有信号量，当缓冲区满时迫使生产者等待
HANDLE g_hEmptySemaphore; //消费者的私有信号量，当缓冲区空时迫使消费者等待
//定义一个结构体用于存储线程的信息
struct ThreadInfo
{
int serial ; //线程号 //填空
char entity; //线程类别(生产者或消费者)
double delay; //等待时间
double persist; //操作时间
};
//生产者
void Producer(void *p)
{
//定义变量用于存储当前线程的信息
DWORD m_delay;
DWORD m_persist;
int m_serial;
//从参数中获得信息
m_serial=((ThreadInfo*)(p))->serial;
m_delay=(DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC);
m_persist=(DWORD)(((ThreadInfo*)(p))->persist *INTE_PER_SEC);
while(running)
{
//P操作
cout<<"生产者线程 "<<m_serial<<" 请求生产."<<endl;
WaitForSingleObject(g_hEmptySemaphore,INFINITE);
cout<<"生产者线程 "<<m_serial<<" 请求独占缓冲区."<<endl;
WaitForSingleObject(g_hMutex,INFINITE);
Sleep(m_delay); //延迟等待
//生产一个产品
cout<<"生产者线程 "<<m_serial<<" 生产 "<<++ProductID <<" 号产品成功." <<endl;
cout<<"生产者线程 "<<m_serial<<" 请求将产品 "<<ProductID<<" 投入缓冲区."<<endl;
//把新生产的产品放入缓冲区
g_buffer[in] = ProductID;
in=(in+1)%SIZE_OF_BUFFER; Sleep(m_persist); //操作等待
cout<<"生产者线程 "<<m_serial<<" 将产品 "<<ProductID<<" 投入缓冲区中成功."<<endl;
//输出缓冲区当前的状态
cout<<"****************************"<<endl
<<"\n当前缓冲区情况如图(■代表已有产品，□代表没有产品): "<<endl;
for (int i=0;i<SIZE_OF_BUFFER;++i)
{
if(g_buffer[i]!=0) cout<<"■";
else cout<<"□";
}
cout<<"\n\n****************************\n"<<endl;
//V操作
ReleaseMutex(g_hMutex);
ReleaseSemaphore(g_hFullSemaphore,1,NULL);
}
}
//消费者
void Consumer(void *p)
{
DWORD m_delay;
DWORD m_persist;
int m_serial;
//从参数中获得信息
m_serial=((ThreadInfo*)(p))->serial ;
m_delay=(DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC);
m_persist=(DWORD)(((ThreadInfo*)(p))->persist *INTE_PER_SEC);
while(running)
{
//P操作
cout<<"消费者线程 "<<m_serial<<" 请求消费."<<endl;
WaitForSingleObject(g_hFullSemaphore,INFINITE);
cout<<"消费者线程 "<<m_serial<<" 请求独占缓冲区."<<endl; WaitForSingleObject(g_hMutex,INFINITE);
Sleep(m_delay); //延迟等待
//从缓冲区中取出一个产品
cout<<"消费者线程 "<<m_serial<<" 请求取出一个产品."<<endl;
ConsumeID = g_buffer[out];
g_buffer[out]=0;
out = (out+1)%SIZE_OF_BUFFER;
cout<<"消费者线程 "<<m_serial<<" 取出产品 "<<ConsumeID<<" 成功."<<endl;
//消耗一个产品
cout<<"消费者线程 "<<m_serial<<" 开始消费消费产品 " <<ConsumeID<<"."<<endl;
Sleep(m_persist);
cout<<"消费者线程 "<<m_serial<<" 消费产品 " <<ConsumeID<<" 成功."<<endl;
//输出缓冲区当前的状态
cout<<"****************************"<<endl
<<"\n当前缓冲区情况如图: "<<endl;
for (int i=0;i<SIZE_OF_BUFFER;++i)
{
if(g_buffer[i]!=0)
cout<<"■";
else cout<<"□";
}
cout<<"\n\n****************************\n"<<endl;
//V操作
ReleaseMutex(g_hMutex);
ReleaseSemaphore(g_hEmptySemaphore,1,NULL);
}
}
void prod_cons()
{
//创建互斥信号量
g_hMutex = CreateMutex(NULL,FALSE,NULL);
//创建同步信号量
g_hEmptySemaphore=CreateSemaphore(NULL,SIZE_OF_BUFFER,SIZE_OF_BUFFER,NULL);
g_hFullSemaphore=CreateSemaphore(NULL,0 ,SIZE_OF_BUFFER,NULL);
srand((unsigned)time(NULL)); //以时间函数为种子
const unsigned short THREADS_COUNT = rand()%5+5; //总的线程数(随机生成)
//线程对象的数组
HANDLE hThreads[MAX_THREAD_NUM];
ThreadInfo thread_info[MAX_THREAD_NUM];
DWORD thread_ID; //线程ID
int num=0; //临时变量，用于循环语句
cout<<"系统开始模拟，并自动生成模拟数据..."<<endl;
system("pause"); //暂停确认开始执行
cout<<"线程总数："<<THREADS_COUNT<<endl;
//循环随机生成各个线程的信息
while(num!=THREADS_COUNT)
{
thread_info[num].serial=num+1;
if(rand()%2==1)
thread_info[num].entity='P';
else
thread_info[num].entity='C';
thread_info[num].delay=rand()%5+1;
thread_info[num].persist=rand()%6+2;
num++;
}
cout<<"\n系统生成数据结束，模拟数据如下:"<<endl
<<"线程号 线程类别 延迟时间 操作时间"<<endl;
for(int x=0;x<THREADS_COUNT;x++)
cout<<" "<<thread_info[x].serial<<"\t"
<<" "<<thread_info[x].entity<<"\t"
<<" "<<thread_info[x].delay<<"\t\t"
<<" "<<thread_info[x].persist<<endl;
cout<<"\n\n============生产者-消费者 开始============\n"<<endl;
//创建线程
for(int i=0;i<THREADS_COUNT;i++)
{
//创建生产者线程
if(thread_info[i].entity=='P') hThreads[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Producer),&thread_info[i],0,&thread_ID);
//创建消费者线程
else hThreads[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Consumer),&thread_info[i],0,&thread_ID);
}
while(running)
{
if(getchar())
{
running = false;
}
}
cout<<"系统模拟结束..."<<endl;
}
int main()
{
cout<<"\n======生产者-消费者 模拟==========\n"<<endl;
prod_cons();
}
六、实验结果分析
1、记录生产者和消费者的同步执行过程
线程号 线程类别 延迟时间 操作时间 操作请求 缓存区请求 生产结果
1 P 1 2 请求生产 请求独占(在2前) 未生产
2 P 2 6 请求生产 请求独占 未消费
3 C 4 5 请求消费 无 未消费
4 C 5 6 请求消费 无 未消费
5 C 3 2 无 无 未消费
2、分析Producer函数和Consumer函数的功能，并画出对应的程序流程图。
Producer函数：通过用变量提取保存提取当前资源信息，然后判断是否执行，接着发出生产请求，请求通过后独占缓冲区资源，接着生产一个产品投入缓冲区，成功后释放所占缓冲区资源，到此此函数执行完成。
Consumer函数：也通过用变量提取保存提取当前资源信息，然后判断是否执行，接着发出消费请求，请求通过后独占缓冲区资源，接着消费一个产品取出缓冲区，成功后释放所占缓冲区资源，到此此函数执行完成。
3、试将同步和互斥的P操作颠倒次序执行，观察并分析程序的运行情况。
程序产生死锁，程序无法正常运行下去，因为同步和互斥的P操作颠倒次序，即先独占缓冲区资源，后发送请求，因为先独占缓冲区资源，若生产（消费）请求无法通过则一直等待，无法释放资源。
3143
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
