C++线程同步消费者生产者实例讲述.docx
《C++线程同步消费者生产者实例讲述.docx》由会员分享，可在线阅读，更多相关《C++线程同步消费者生产者实例讲述.docx（14页珍藏版）》请在冰豆网上搜索。
C++线程同步消费者生产者实例讲述
C++线程同步成产者消费者举例
1.测试用例文件
说明：
本用例是在VS2010（中文版）环境下进行。
项目创建流程（只供参考）：
文件à新建àVisualC++àWin32项目à
输入项目名（ThreadPC）à确定à下一步à选择控制台应用程序à完成
测试用例文件用于描述各线程的有关信息，该文件内容及格式如下（将下列内容复制到test.txt文件中）：
3
1P3
2P4
3C41
4P2
5C3124
说明：
第一行给出的是程序中设置的临界区个数；其余各行是各进程信息。
每行中的数据之间用Tab键分隔。
第一列（除第一行外）：
线程号（共5个线程）。
第二列：
P——生产者，C——消费者。
第三列：
线程在生产和消费前的休眠时间，单位为秒。
第四及以后各列：
消费的产品所对应的生产者线程号。
2.数据结构
（1）用整型数组Buffer_Critical表示缓冲区。
//本程序允许的最大临界区数
#defineMAX_BUFFER_NUM10
intBuffer_Critical[MAX_BUFFER_NUM];//缓冲区声明，用于存放产品
（2）用自定义结构ThreadInfo记录一条线程信息，多个线程对应一个ThreadInfo数组。
structThreadInfo
{
intserial;//线程序列号
charentity;//是P还是C
doubledelay;//线程延迟
intthread_request[MAX_THREAD_NUM];//线程请求队列
intn_request;//请求个数
};
（3）通过如下同步对象实现互斥：
●设一个互斥量h_mutex，实现生产者在查询和保留缓冲区的下一个空位置时进行互斥。
HANDLEh_mutex;//一个互斥量
●设置h_Semaphore[MAX_THREAD_NUM]信号量数组表示相应产品已经生产，实现生产者与消费者之间的同步。
同时，用表示空缓冲区数目的信号量empty_semephore指示是否存在空位置，实现类似的同步，以便开始下一个产品的生产。
//本程序允许的生产和消费线程的总数
#defineMAX_THREAD_NUM64
HANDLEh_Semaphore[MAX_THREAD_NUM];//生产者允许消费者开始消费的信号量
●设置临界区对象数组PC_Critical[MAX_BUFFER_NUM]实现每个缓冲区上消费者之间的互斥。
CRITICAL_SECTIONPC_Critical[MAX_BUFFER_NUM];//临界区对象的声明,用于管理缓冲区的互斥访问
3.程序流程
为了方便，程序结构用如下的文字予以描述。
（1）主函数
（2）初始化缓冲区、消费请求队列及部分同步对象
（3）提取线程信息（到test.txt文件中提取）
（4）完成线程相关同步对象的初始化
（5）创建线程，模拟生产者和消费者
（6）等待所有线程结束
（7）程序结束
（8）消费者
（9）有无消费请求？
有，则继续（10）；无，则转（16）
（10）此请求可满足？
可满足，转（11）；否，则阻塞，再转（10）
（11）确定产品位置
（12）此产品正被消费？
是，则阻塞，再转（12）；否，则转（13）
（13）进入临界区（请求同一产品的消费者之间互斥）
（14）消费产品，并判断是否应该释放产品所占缓冲区
（15）退出临界区，转（9）
（16）结束消费者线程
（17）生产者
（18）存在空缓冲区？
有，则继续（19）；无，则阻塞，再转（18）
（19）另一生产者在写？
否，则转（20）；是，则阻塞，再转（19）
（20）进入临界区（请求同一产品的生产者之间互斥）
（21）在缓冲区中为本线程产品分配空间
（22）退出临界区
（23）写入产品到分配的缓冲区空间中
（24）结束生产者线程
4.代码实现
//ThreadPC.cpp:
定义控制台应用程序的入口点
#include"stdafx.h"
#include
#include
#include
#include
#include
#include
usingnamespacestd;
//定义一些常量
//本程序允许的最大临界区数
#defineMAX_BUFFER_NUM10
//秒到微秒的乘法因子
#defineINTE_PER_SEC1000
//本程序允许的生产和消费线程的总数
#defineMAX_THREAD_NUM64
//定义一个结构，记录在测试文件中指定的每一个线程的参数
structThreadInfo
{
intserial;//线程序列号
charentity;//是P还是C
doubledelay;//线程延迟
intthread_request[MAX_THREAD_NUM];//线程请求队列
intn_request;//请求个数
};
//全局变量的定义
//struct_RTL_CRITICAL_SECTION;
//typedef_RTL_CRITICAL_SECTIONRTL_CRITICAL_SECTION;
//typedefRTL_CRITICAL_SECTIONCRITICAL_SECTION;
CRITICAL_SECTIONPC_Critical[MAX_BUFFER_NUM];//临界区对象的声明,用于管理缓冲区的互斥访问
intBuffer_Critical[MAX_BUFFER_NUM];//缓冲区声明，用于存放产品
HANDLEh_Thread[MAX_THREAD_NUM];//用于存储每个线程句柄的数组
ThreadInfoThread_Info[MAX_THREAD_NUM];//线程信息数组
HANDLEempty_semaphore;//一个信号量
HANDLEh_mutex;//一个互斥量
DWORDn_Thread=0;//实际的线程的数目
DWORDn_Buffer_or_Critical;//实际的缓冲区或者临界区的数目
HANDLEh_Semaphore[MAX_THREAD_NUM];//生产者允许消费者开始消费的信号量
//生产消费及辅助函数的声明
voidProduce（void*p）;
voidConsume（void*p）;
boolIfInOtherRequest（int）;
intFindProducePosition（）;
intFindBufferPosition（int）;
intmain（void）
{
//声明所需变量
inti=0,j=0;
DWORDwait_for_all;
ifstreaminFile;//输入文件
//初始化缓冲区，即产品缓冲区，存储生产的产品，产品为正整数，-1表示空
for（inti=0;iBuffer_Critical[i]=-1;
//初始化每个线程的请求队列
for（intj=0;jfor（intk=0;kThread_Info[j].thread_request[k]=-1;//-1表示无请求，正整数表示生产者请求生产的产品或消费者请求消费的产品
Thread_Info[j].n_request=0;
}
//初始化临界区对象列表，使用临界区是必须初始化
for（i=0;iInitializeCriticalSection（&PC_Critical[i]）;
//打开输入文件，按照规定的格式提取线程等信息
inFile.open（"test.txt"）;
//从文件中获得实际的缓冲区或临界区对象的数目
inFile>>n_Buffer_or_Critical;//=3
inFile.get（）;//读取\n
printf（"输入文件是:
\n"）;
//回显获得的缓冲区的数目信息
printf（"缓冲区的数目是：
%d\n",（int）n_Buffer_or_Critical）;
//提取每个线程的信息到相应数据结构中
while（inFile）{
inFile>>Thread_Info[n_Thread].serial;//线程号
inFile>>Thread_Info[n_Thread].entity;//P—生产者，C—消费者
inFile>>Thread_Info[n_Thread].delay;//线程在生产和消费前的休眠时间，单位为秒
charc;
inFile.get（c）;
while（c!
='\n'&&!
inFile.eof（））{//c!
='\n'说明delay列后面还有数据
inFile>>
Thread_Info[n_Thread].thread_request[Thread_Info[n_Thread].n_request++];
inFile.get（c）;
}
n_Thread++;
}
//输出获得的线程信息，便于确认正确性
cout<<"从文件中获得的线程信息"<cout<<"serial\tentity\tdelay\trequest\t..."<for（j=0;j<（int）n_Thread;j++）{
intTemp_serial=Thread_Info[j].serial;
charTemp_entity=Thread_Info[j].entity;
doubleTemp_delay=Thread_Info[j].delay;
printf（"\n线程%2d\t%c\t%f\t",Temp_serial,Temp_entity,Temp_delay）;
intTemp_request=Thread_Info[j].n_request;
for（intk=0;kprintf（"%d\t",Thread_Info[j].thread_request[k]）;
cout<}
printf（"\n\n"）;
//创建信号量empty_semaphore控制同一时刻访问空缓冲区域的线程数目
empty_semaphore=CreateSemaphore（NULL,n_Buffer_or_Critical,n_Buffer_or_Critical,（LPCWSTR）"semaphore_for_empty"）;
//互斥量h_mutex，实现生产者在查询和保留缓冲区的下一个空位置时进行互斥
h_mutex=CreateMutex（NULL,FALSE,（LPCWSTR）"mutex_for_update"）;
//下面这个循环用线程的ID号来为相应生产线程的产品读写时所使用的同步信号量命名
for（j=0;j<（int）n_Thread;j++）{
std:
:
stringlp="semaphore_for_produce_";
inttemp=j;
while（temp）{//将tmp转化为字符串
charc=（char）（temp%10）+'0';
lp+=c;
temp/=10;
}
//信号量h_Semaphore[i]控制被生产者线程h_Thread[i]生产的线程可以被多少个消费线程使用
h_Semaphore[j+1]=CreateSemaphore（NULL,0,（LONG）n_Thread,（LPCWSTR）lp.c_str（））;
}
//创建生产者和消费者线程
for（i=0;i<（int）n_Thread;i++）{
if（Thread_Info[i].entity=='P'）
h_Thread[i]=CreateThread（NULL,0,（LPTHREAD_START_ROUTINE）（Produce）,&（Thread_Info[i]）,0,NULL）;
else
h_Thread[i]=CreateThread（NULL,0,（LPTHREAD_START_ROUTINE）（Consume）,&（Thread_Info[i]）,0,NULL）;
}
//主程序等待各个线程的动作结束
wait_for_all=WaitForMultipleObjects（n_Thread,h_Thread,TRUE,-1）;
printf（"\n\n所有的生产者和消费者已经完成他们的工作.\n"）;
printf（"按任意键退出！
\n"）;
_getch（）;
return0;
}
//确认是否还有对同一产品的消费请求未执行
boolIfInOtherRequest（intreq）
{
for（unsignedinti=0;ifor（intj=0;jif（Thread_Info[i].thread_request[j]==req）
returnTRUE;
returnFALSE;
}
//找出当前可以进行产品生产的空缓冲区位置
intFindProducePosition（）
{
intEmptyPosition;
for（unsignedinti=0;iif（Buffer_Critical[i]==-1）{
EmptyPosition=i;
//用下面这个特殊值表示本缓冲区正处于被写状态
Buffer_Critical[i]=-2;
break;
}
returnEmptyPosition;
}
//找出当前所需生产者生产的产品的位置
intFindBufferPosition（intProPos）
{
intTempPos;
for（unsignedinti=0;iif（Buffer_Critical[i]==ProPos）{
TempPos=i;
break;
}
returnTempPos;
}
//生产者进程
voidProduce（void*p）
{
//局部变量声明
DWORDwait_for_semaphore,wait_for_mutex,m_delay;
intm_serial;
//获得本线程的信息
m_serial=（（ThreadInfo*）（p））->serial;//本线程序号
m_delay=（DWORD）（（（ThreadInfo*）（p））->delay*INTE_PER_SEC）;//开始生产或消费之前的等待时间
Sleep（m_delay）;
//开始请求生产
printf（"生产者%2d发送生产请求！
\n",m_serial）;
//确认有空缓冲区可供生产，同时将控制访问空位置线程数目的信号量empty_semaphore的计数器减
wait_for_semaphore=WaitForSingleObject（empty_semaphore,-1）;
//等待互斥量，互斥访问下一个可用于生产的空临界区，实现写互斥
wait_for_mutex=WaitForSingleObject（h_mutex,-1）;
//生产者获取生产位置，有互斥量可保证不同生产这可以找到不同的生产位置，同时信号量empty_semaphore可以保证生产者线程数不超过空位置数
intProducePos=FindProducePosition（）;
//释放互斥量
ReleaseMutex（h_mutex）;
//生产者在获得自己的空位置并做上标记后，以下的写操作在生产者之间可以并发在核心生产步骤中，程序将生产者的ID作为产品编号放入，方便消费者识别
printf（"生产者%2d开始在位置%2d上生产！
\n",m_serial,ProducePos）;
//生产者生产中
Buffer_Critical[ProducePos]=m_serial;
printf（"生产者%2d完成生产；\n",m_serial）;
printf（"位置[%2d]：
%3d\n",ProducePos,Buffer_Critical[ProducePos]）;
//使生产者写的缓冲区可以被多个消费者使用，实现读写同步
ReleaseSemaphore（h_Semaphore[m_serial],n_Thread,NULL）;
}
//消费者进程
voidConsume（void*p）
{
//局部变量声明
DWORDwait_for_semaphore,m_delay;
intm_serial,m_requestNum;//消费者的序列号和请求的数目
intm_thread_request[MAX_THREAD_NUM];//本消费线程的请求队列
//提取本线程的信息到本地
m_serial=（（ThreadInfo*）（p））->serial;
m_delay=（DWORD）（（（ThreadInfo*）（p））->delay*INTE_PER_SEC）;
m_requestNum=（（ThreadInfo*）（p））->n_request;
for（inti=0;im_thread_request[i]=（（ThreadInfo*）（p））->thread_request[i];
Sleep（m_delay）;
//循环进行所需产品的消费
for（inti=0;i//请求消费下一个产品
printf（"消费者%2d请求消费产品%2d\n",m_serial,m_thread_request[i]）;
//如果对应生产者没有生产，则等待；
//如果生产了,允许的消费者数目为-1；实现了读写同步，
//h_Semaphore[m_thread_request[i]]控制所请求的产品m_thread_request[i]可以被多少个消费者线程使用
wait_for_semaphore=WaitForSingleObject（h_Semaphore[m_thread_request[i]],-1）;
//查询所需产品放到缓冲区的下标号
intBufferPos=FindBufferPosition（m_thread_request[i]）;
//开始进行具体缓冲区的消费处理，读和读在该缓冲区上仍然是互斥的
//进入临界区后执行消费动作；并在完成此次请求后，通知另外的消费者本处请求已经满足；
//同时如果对应的产品使用完毕，就做相应处理；并给出相应动作的界面提示；
//该相应处理指将相应缓冲区清空，并增加代表空缓冲区的信号量
//PC_Critical[BufferPos]控制BufferPos位置的产品不同时被两个及两个以上的消费者线程消费
EnterCriticalSection（&PC_Critical[BufferPos]）;
printf（"消费者%2d开始消费产品%2d\n",m_serial,m_thread_request[i]）;
（（ThreadInfo*）（p））->thread_request[i]=-1;
if（!
IfInOtherRequest（m_thread_request[i]））{
Buffer_Critical[BufferPos]=-1;//标记缓冲区为空
printf（"消费者%2d完成消费%2d:
\n",m_serial,m_thread_request[i]）;
printf（"位置[%2d]:
%3d\n",BufferPos,Buffer_Critical[BufferPos]）;
ReleaseSemaphore（empty_semaphore,1,NULL）;
}
else{
printf（"消费者%2d完成消费产品%2d\n",m_serial,m_thread_request[i]）;
}
//离开临界区
LeaveCriticalSection（&PC_Critical[BufferPos]）;
}
}
升级会员 