实验二-进程(线程)的同步与互斥.doc

实验二 进程（线程）的同步与互斥

一、实验目的
1． 掌握基本的同步与互斥算法，理解生产者消费者模型。
2． 学习使用Windows中基本的同步对象，掌握相关API的使用方法。
3． 了解Windows中多线程的并发执行机制，实现进程的同步与互斥。

二、实验内容
1． 实验内容
以生产者/消费者模型为依据，在Windows 环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。
Buffer(共享内存)
生产者
消费者

2． 实验要求
l 学习并理解生产者/消费者模型及其同步/互斥规则；
l 学习了解Windows同步对象及其特性；
l 熟悉实验环境，掌握相关API的使用方法；
l 设计程序，实现生产者/消费者进程(线程)的同步与互斥；

三、相关API的功能及使用
我们利用Windows SDK提供的API编程实现实验题目要求，而VC中包含有Windows SDK的所有工具和定义。要使用这些API，需要包含堆这些函数进行说明的SDK头文件——最常见的是Windows.h(特殊的API调用还需要包含其他头文件)。
下面给出的是本实验使用到的API的功能和使用方法简单介绍。
(1) CreateThread
l 功能——创建一个在调用进程的地址空间中执行的线程
l 格式
HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParamiter,
DWORD dwCreationFlags,
Lpdword lpThread );
l 参数说明
lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。
dwStackSize——定义原始堆栈大小。
lpStartAddress——指向使用LPTHRAED_START_ROUTINE类型定义的函数。
lpParamiter——定义一个给进程传递参数的指针。
dwCreationFlags——定义控制线程创建的附加标志。
lpThread——保存线程标志符(32位)
(2) CreateMutex
l 功能——创建一个命名或匿名的互斥量对象
l 格式
HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes,
BOOL bInitialOwner,
LPCTSTR lpName);
l 参数说明
lpMutexAttributes——必须取值NULL。
bInitialOwner——指示当前线程是否马上拥有该互斥量(即马上加锁)。
lpName——互斥量名称。
(3) CreateSemaphore
l 功能——创建一个命名或匿名的信号量对象
l 格式
HANDLE CreateSemaphore(LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
LONG lInitialCount,
LONG lMaximumCount,
LPCTSTR lpName );
l 参数说明
lpSemaphoreAttributes——必须取值NULL。
lInitialCount——信号量的初始值。该值大于等于0，但小于等于lMaximumCount指定的最大值。
lMaximumCount——信号量的最大值。
lpName——信号量名称。
(4) WaitForSingleObject
l 功能——使程序处于等待状态，直到信号量hHandle出现(即其值大于0)或超过规定的等待时间
l 格式
DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
l 参数说明
hHandle——信号量指针。
dwMilliseconds——等待的最长时间(INFINITE为无限等待)。
(5) ReleaseSemaphore
l 功能——对指定信号量加上一个指定大小的量。成功执行则返回非0值
l 格式
BOOL ReleaseSemaphore(HANDLE hSemaphore,
LONG lReleaseCount,
LPLONG lppreviousCount );
l 参数说明
hSemaphore——信号量指针。
lReleaseCount——信号量的增量。
lppreviousCount——保存信号量当前值。
(6) ReleaseMutex
l 功能——打开互斥锁，即把互斥量加1。成功调用则返回0
l 格式
BOOL ReleaseMutex(HANDLE hMutex);
l 参数说明
hMutex——互斥量指针。

四、示例程序
//定义一个结构体用于存储线程的信息
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<10;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<10;i++){
if(g_buffer[i]>0 )
cout<<"■";
else cout<<"□";
}
cout<<"\n\n****************************\n"<<endl;

//V操作
ReleaseMutex(g_hMutex);
ReleaseSemaphore(g_hEmptySemaphore,1,NULL);
}
}

五、实验结果

六、实验结果分析
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函数：也是通过用变量提取保存提取当前资源信息，然后判断是否执行，接着发出消费请求,请求通过后独占缓冲区资源，接着消费一个产品取出缓冲区，成功后释放所占缓冲区资源，到此此函数执行完成。
Producer函数： Consumer函数：
3、试将同步和互斥的P操作颠倒次序执行，观察并分析程序的运行情况。
答：程序产生死锁。程序无法正常运行下去，因为同步和互斥的P操作颠倒次序，即先独占缓冲区资源，后发送请求，因为先独占缓冲区资源，若生产（消费）请求无法通过则一直等待，无法释放资源，因而程序死锁，无法运行了。