昨天很幸运的找到了这个系列的博客 http://blog.csdn.net/morewindows/article/details/7421759，点击打开链接

学习了一下关于多线程的知识，前面的系列讲解的非常详细，并且对生产消费这一篇（csdn博客无法打开，在其他网址浏览的）做了相关的代码实践记录如下备忘：

/////////////////////情景1：//////////////////
//1生产者 1消费者 1缓冲区  
//使用二个事件，一个表示缓冲区空，一个表示缓冲区满。  
//再使用一个关键段来控制缓冲区的访问//#include <stdio.h>  
//#include <process.h>  
//#include <windows.h>
//
//CRITICAL_SECTION  g_csThreadCode;
//HANDLE  g_hEventFull;//表示缓冲区满
//HANDLE  g_hEventEmpty;//表示缓冲区空
//
//volatile long Datanum; //每次产生或者读取的数据
//const int END_PRODUCE_NUMBER = 10;   //生产产品个数
//unsigned int __stdcall ProduceThread(void *pPM) {
//	for (int i = 0; i < END_PRODUCE_NUMBER; i++) {
//		WaitForSingleObject(g_hEventEmpty, INFINITE); //等待"缓冲区空"事件被触发
//		InitializeCriticalSection(&g_csThreadCode);
//		Datanum = i;
//		printf("产生数据：%d\n",Datanum);
//		LeaveCriticalSection(&g_csThreadCode);
//		SetEvent(g_hEventFull); //触发"缓冲区满"事件
//	}
//	return 0;
//}
//unsigned int __stdcall ConsumeThread(void *pPM) {
//	int ReadData;
//	for (int i = 0; i < END_PRODUCE_NUMBER; i++) {
//		WaitForSingleObject(g_hEventFull, INFINITE); //等待"缓冲区满"事件被触发
//		InitializeCriticalSection(&g_csThreadCode);
//		ReadData = Datanum;
//		printf("消费数据：%d\n", ReadData);
//		LeaveCriticalSection(&g_csThreadCode);
//		SetEvent(g_hEventEmpty); //触发"缓冲区满"事件
//		
//	}
//	return 0;
//}
//int main() {
//
//	//初始化
//	g_hEventFull = CreateEvent(NULL, FALSE, FALSE, NULL);//初始化时将 “g_hEventFull “事件设置为FALSE未激发态
//	g_hEventEmpty = CreateEvent(NULL, FALSE, TRUE, NULL);// 初始化时将 “g_hEventEmpty“事件设置为TRUE激发态
//
//	InitializeCriticalSection(&g_csThreadCode);
//	const int THREADNUM = 2;
//	HANDLE hThread[THREADNUM];
//	hThread[0] =(HANDLE)_beginthreadex(NULL, 0, ProduceThread, NULL, 0, NULL);
//	hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumeThread, NULL, 0, NULL);
//	WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
//	CloseHandle(hThread[0]);
//	CloseHandle(hThread[1]);
//
//	//销毁事件和关键段  
//	CloseHandle(g_hEventFull);
//	CloseHandle(g_hEventEmpty);
//	DeleteCriticalSection(&g_csThreadCode);
//	system("pause");
//	return 0;
//}/////////////////////情景2：//////////////////
////1生产者 2消费者 4缓冲区  
//用一个信号量A来记录为空的缓冲区个数，另一个信号量B记录非空的缓冲区个数，
//然后生产者等待信号量A，消费者等待信号量B就可以了
//再使用一个关键段来控制缓冲区的访问//#include <stdio.h>  
//#include <process.h>  
//#include <windows.h>
//const int END_PRODUCE_NUMBER = 8;  //生产产品个数  
//const int BUFFER_SIZE = 4;          //缓冲区个数  
//int g_Buffer[BUFFER_SIZE];          //缓冲池  
//int g_i, g_j;
////信号量与关键段  
//CRITICAL_SECTION g_cs;
//HANDLE g_hSemaphoreBufferEmpty, g_hSemaphoreBufferFull;
////生产者线程函数  
//unsigned int __stdcall ProducerThreadFun(PVOID pM)
//{
//	for (int i = 1; i <= END_PRODUCE_NUMBER; i++)
//	{
//		//等待有空的缓冲区出现  
//		WaitForSingleObject(g_hSemaphoreBufferEmpty, INFINITE);
//
//		//互斥的访问缓冲区  
//		EnterCriticalSection(&g_cs);
//		g_Buffer[g_i] = i;
//		printf("生产者在缓冲池第%d个缓冲区中投放数据%d\n", g_i, g_Buffer[g_i]);
//		g_i = (g_i + 1) % BUFFER_SIZE;
//		LeaveCriticalSection(&g_cs);
//
//		//通知消费者有新数据了  
//		ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
//	}
//	printf("生产者完成任务，线程结束运行\n");
//	return 0;
//}
////消费者线程函数  
//unsigned int __stdcall ConsumerThreadFun(PVOID pM)
//{
//	while (true)
//	{
//		//等待非空的缓冲区出现  
//		WaitForSingleObject(g_hSemaphoreBufferFull, INFINITE);
//
//		//互斥的访问缓冲区  
//		EnterCriticalSection(&g_cs);
//
//		printf("  编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d\n", GetCurrentThreadId(), g_j, g_Buffer[g_j]);
//		if (g_Buffer[g_j] == END_PRODUCE_NUMBER)//结束标志  
//		{
//			LeaveCriticalSection(&g_cs);
//			//通知其它消费者末尾的数据(结束标志)  
//			ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);//Full信号量++
//			 //不再移动缓冲池中的区块下标，因为已经取到了最后的一个数据
//			break;
//		}
//
//		g_j = (g_j + 1) % BUFFER_SIZE;//移动缓冲池中的区块下标，为了下次取数据
//		LeaveCriticalSection(&g_cs);
//
//
//		ReleaseSemaphore(g_hSemaphoreBufferEmpty, 1, NULL);//Empty信号量++
//	}
//
//	printf("  编号为%d的消费者收到通知，线程结束运行\n", GetCurrentThreadId());
//	return 0;
//}
//int main() {
//
//	InitializeCriticalSection(&g_cs);
//	//初始化信号量,一个记录有产品的缓冲区个数,另一个记录空缓冲区个数.  
//	g_hSemaphoreBufferEmpty = CreateSemaphore(NULL, 4, 4, NULL);//当前4个资源，最大允许4个同时访问 
//	g_hSemaphoreBufferFull = CreateSemaphore(NULL, 0, 4, NULL);//当前0个资源，最大允许4个同时访问 
//	g_i = 0;
//	g_j = 0;
//	memset(g_Buffer, 0, sizeof(g_Buffer));
//	const int THREADNUM = 3;
//	HANDLE hThread[THREADNUM];
//	//生产者线程  
//	hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
//	//消费者线程  
//	hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
//	hThread[2] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
//	WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
//	for (int i = 0; i < THREADNUM; i++)
//		CloseHandle(hThread[i]);
//
//	//销毁信号量和关键段  
//	CloseHandle(g_hSemaphoreBufferEmpty);
//	CloseHandle(g_hSemaphoreBufferFull);
//	DeleteCriticalSection(&g_cs);
//	system("pause");
//	return 0;
//}/////////////////////情景3：/////////////////////
////2生产者 2消费者 4缓冲区  
//用一个信号量A来记录为空的缓冲区个数，另一个信号量B记录非空的缓冲区个数，
//然后生产者等待信号量A，消费者等待信号量B就可以了
//再使用一个关键段来控制缓冲区的访问//#include <stdio.h>  
//#include <process.h>  
//#include <windows.h>
//volatile BOOL ProRun;              //生产者线程控制标志
//volatile int iData;				   //产品的标注
//const int END_PRODUCE_NUMBER = 8;  //生产产品个数  
//const int BUFFER_SIZE = 4;         //缓冲区个数  
//int g_Buffer[BUFFER_SIZE];         //缓冲池  
//int g_i, g_j;
////信号量与关键段  
//CRITICAL_SECTION g_cs;
//HANDLE g_hSemaphoreBufferEmpty, g_hSemaphoreBufferFull;
//
////设置控制台输出颜色  
//BOOL SetConsoleColor(WORD wAttributes)
//{
//	HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
//	if (hConsole == INVALID_HANDLE_VALUE)
//		return FALSE;
//
//	return SetConsoleTextAttribute(hConsole, wAttributes);
//}
//
////生产者线程函数  
//unsigned int __stdcall ProducerThreadFun(PVOID pM)
//{
//	while (ProRun)
//	{
//		//等待有空的缓冲区出现  
//		WaitForSingleObject(g_hSemaphoreBufferEmpty, INFINITE);
//
//		//互斥的访问缓冲区  
//		EnterCriticalSection(&g_cs);
//		iData++;
//		if (iData > END_PRODUCE_NUMBER)//结束标志,所有数据已经生产完毕
//		{
//			ProRun = FALSE;//通知其他生产者结束线程
//			LeaveCriticalSection(&g_cs);
//			break;
//		}
//		else
//		{
//			g_Buffer[g_i] = iData;
//			printf("编号为%d的生产者在缓冲池第%d个缓冲区中投放数据%d\n", GetCurrentThreadId(), g_i, g_Buffer[g_i]);
//			g_i = (g_i + 1) % BUFFER_SIZE;
//			LeaveCriticalSection(&g_cs);
//			//通知消费者有新数据了  
//			ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
//		}
//	}
//
//	printf("编号为%d生产者完成任务，线程结束运行\n", GetCurrentThreadId());
//	return 0;
//}
//
////消费者线程函数  
//unsigned int __stdcall ConsumerThreadFun(PVOID pM)
//{
//	while (true)
//	{
//		//等待非空的缓冲区出现  
//		WaitForSingleObject(g_hSemaphoreBufferFull, INFINITE);
//
//		//互斥的访问缓冲区  
//		EnterCriticalSection(&g_cs);
//		SetConsoleColor(FOREGROUND_GREEN);
//		printf("  编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d\n", GetCurrentThreadId(), g_j, g_Buffer[g_j]);
//		SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN| FOREGROUND_BLUE);
//		if (g_Buffer[g_j] == END_PRODUCE_NUMBER)//结束标志  
//		{
//			LeaveCriticalSection(&g_cs);
//			//通知其它消费者末尾的数据(结束标志)  
//			ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);//Full信号量++
//															  //不再移动缓冲池中的区块下标，因为已经取到了最后的一个数据
//			break;
//		}
//
//		g_j = (g_j + 1) % BUFFER_SIZE;//移动缓冲池中的区块下标，为了下次取数据
//		LeaveCriticalSection(&g_cs);
//
//
//		ReleaseSemaphore(g_hSemaphoreBufferEmpty, 1, NULL);//Empty信号量++
//	}
//	SetConsoleColor(FOREGROUND_GREEN);
//	printf("  编号为%d的消费者收到通知，线程结束运行\n", GetCurrentThreadId());
//	SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
//	return 0;
//}
//int main() {
//
//	InitializeCriticalSection(&g_cs);
//	//初始化信号量,一个记录有产品的缓冲区个数,另一个记录空缓冲区个数.  
//	g_hSemaphoreBufferEmpty = CreateSemaphore(NULL, 4, 4, NULL);//当前4个资源，最大允许4个同时访问 
//	g_hSemaphoreBufferFull = CreateSemaphore(NULL, 0, 4, NULL);//当前0个资源，最大允许4个同时访问
//	ProRun = TRUE;
//	iData = 0;
//	g_i = 0;
//	g_j = 0;
//
//	memset(g_Buffer, 0, sizeof(g_Buffer));
//	const int THREADNUM = 4;
//	HANDLE hThread[THREADNUM];
//	//生产者线程  
//	hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
//	hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
//	//消费者线程  
//	hThread[2] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
//	hThread[3] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
//	WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
//	for (int i = 0; i < THREADNUM; i++)
//		CloseHandle(hThread[i]);
//
//	//销毁信号量和关键段  
//	CloseHandle(g_hSemaphoreBufferEmpty);
//	CloseHandle(g_hSemaphoreBufferFull);
//	DeleteCriticalSection(&g_cs);
//	system("pause");
//	return 0;
//}