API 练习 第一篇

练习API  
CreateSemaphore
CreateEvent
ReleaseSemap
WaitForSingleObject 
CloseHandle
InitializeCriticalSection
EnterCriticalSection
LeaveCriticalSection
DeleteCriticalSection
例子：读者与写者，有一位写者与三位读者，要求当三位读者都读操作完成时写者才能开始写操作，写的过程中不能有任何读者进行读操作。用信号量解决问题
代码如下：

// ReaderAndWriter.cpp : 定义控制台应用程序的入口点。
//
 
#include "stdafx.h"
#include <Windows.h>
#include <stdio.h>
 
int gBook = 0;
CRITICAL_SECTION cs;
 
//线程句柄
HANDLE hThread[4];
 
//线程体
DWORD WINAPI threadWrite(void *param);
DWORD WINAPI threadRead1(void *param);
DWORD WINAPI threadRead2(void *param);
DWORD WINAPI threadRead3(void *param);
 
//信号量句柄
HANDLE hWriteSM;
HANDLE hRead1SM;
HANDLE hRead2SM;
HANDLE hRead3SM;
 
//线程退出事件
HANDLE hEventWriteExit;
HANDLE hEventRead1Exit;
HANDLE hEventRead2Exit;
HANDLE hEventRead3Exit;
 
/********************************************
程序说明：
一个写线程与三个读线程共同访问gBook，要求当三
个读线程都读完后，写线程才开始写gBook。
主线程等待6秒后通知退出事件，清理资源，结束程序
*********************************************/

int _tmain(int argc, _TCHAR* argv[])
{
        //初始化临界区
	InitializeCriticalSection(&cs);
        //线程退出事件
	hEventWriteExit = CreateEvent(NULL, false, false, NULL);
	hEventRead1Exit = CreateEvent(NULL, false, false, NULL);
	hEventRead2Exit = CreateEvent(NULL, false, false, NULL);
	hEventRead3Exit = CreateEvent(NULL, false, false, NULL);
        //创建读者写者信号量
	hWriteSM = CreateSemaphore(NULL, 0, 3, NULL);//写信号量初始为unsignal ，可知先进行的是读操作
	hRead1SM = CreateSemaphore(NULL, 1, 1, NULL);//读信号量初始为signal，
        hRead2SM = CreateSemaphore(NULL, 1, 1, NULL);//读信号量初始为signal，
	hRead3SM = CreateSemaphore(NULL, 1, 1, NULL);//读信号量初始为signal，
        //创建四个线程
	hThread[0] = CreateThread(NULL, 0, threadWrite, NULL, 0, NULL);
	hThread[1] = CreateThread(NULL, 0, threadRead1, NULL, 0, NULL);
	hThread[2] = CreateThread(NULL, 0, threadRead2, NULL, 0, NULL);
	hThread[3] = CreateThread(NULL, 0, threadRead3, NULL, 0, NULL);
        //等待线程执行6秒
	Sleep(1000 * 6);
        //发出通知线程结束事件
	SetEvent(hEventWriteExit);
	SetEvent(hEventRead1Exit);
	SetEvent(hEventRead2Exit);
	SetEvent(hEventRead3Exit);
        //等待四个线程都结束
	WaitForMultipleObjects(4, hThread, true, INFINITE);
       //关闭句柄，清理资源
	CloseHandle(hEventWriteExit);
	CloseHandle(hEventRead1Exit);
	CloseHandle(hEventRead2Exit);
	CloseHandle(hEventRead3Exit);
 
	CloseHandle(hWriteSM);
	CloseHandle(hRead1SM);
	CloseHandle(hRead2SM);
	CloseHandle(hRead3SM);
 
	for (int i = 0; i < 4; i ++)
		CloseHandle(hThread[i]);
 
	DeleteCriticalSection(&cs);
 
	printf("\t main end \n");
 
	return 0;
}
 
DWORD WINAPI threadWrite(void *param)
{
	while(1)
	{
		DWORD dwWait = WaitForSingleObject(hEventWriteExit, 10);
		if (WAIT_TIMEOUT != dwWait)
		{
			//接收到退出事件后先把资源归还，避免造成死锁
			ReleaseSemaphore(hRead1SM, 1, NULL);
			ReleaseSemaphore(hRead2SM, 1, NULL);
			ReleaseSemaphore(hRead3SM, 1, NULL);
			break;
		}
		WaitForSingleObject(hWriteSM, INFINITE);
		WaitForSingleObject(hWriteSM, INFINITE);
		WaitForSingleObject(hWriteSM, INFINITE);
 
		EnterCriticalSection(&cs);
		gBook ++;
		printf(" \n Write Process end:%d \n", gBook);
		LeaveCriticalSection(&cs);
 
		ReleaseSemaphore(hRead1SM, 1, NULL);
		ReleaseSemaphore(hRead2SM, 1, NULL);
		ReleaseSemaphore(hRead3SM, 1, NULL);
 
		Sleep(1000);
	}
 
	printf("\n******************writer Terminate \n");
	return 0;
}
 
DWORD WINAPI threadRead1(void *param)
{
	while(1)
	{
		DWORD dwWait = WaitForSingleObject(hEventRead1Exit, 10);
		if (WAIT_TIMEOUT != dwWait)
		{
			//接收到退出事件后先把资源归还，避免造成死锁
			ReleaseSemaphore(hWriteSM, 1, NULL);
			break;
		}
		WaitForSingleObject(hRead1SM, INFINITE);
		EnterCriticalSection(&cs);
		printf("reader1 process end %d \t", gBook);
		LeaveCriticalSection(&cs);
 
		ReleaseSemaphore(hWriteSM, 1, NULL);
 
		Sleep(100 * 1);
	}
 
	printf("\n******************read1 Terminate \n");
	return 0;
}
 
DWORD WINAPI threadRead2(void *param)
{
	while(1)
	{
		DWORD dwWait = WaitForSingleObject(hEventRead2Exit, 10);
		if (WAIT_TIMEOUT != dwWait)
		{
			//接收到退出事件后先把资源归还，避免造成死锁
			ReleaseSemaphore(hWriteSM, 1, NULL);
			break;
		}
		WaitForSingleObject(hRead2SM, INFINITE);
		EnterCriticalSection(&cs);
		printf("reader2 process end %d \t", gBook);
		LeaveCriticalSection(&cs);
 
		ReleaseSemaphore(hWriteSM, 1, NULL);
 
		Sleep(1000 * 0.5);
	}
 
	printf("\n******************reader2 Terminate \n");
	return 0;
}
DWORD WINAPI threadRead3(void *param)
{
	while(1)
	{
		//接收到退出事件后先把资源归还，避免造成死锁
		DWORD dwWait = WaitForSingleObject(hEventRead3Exit, 10);
		if (WAIT_TIMEOUT != dwWait)
		{
			ReleaseSemaphore(hWriteSM, 1, NULL);
			break;
		}
		WaitForSingleObject(hRead3SM, INFINITE);
 
		EnterCriticalSection(&cs);
		printf("reader3 process end %d \t", gBook);
		LeaveCriticalSection(&cs);
 
		ReleaseSemaphore(hWriteSM, 1, NULL);
 
		Sleep(1000 * 1);
	}
 
	printf("\n******************reader3 Terminate \n");
	return 0;
}

结果如下：

说明：三个读线程读完后，写线程开始写操作，克制结果正确。每次执行时可能结果有所不同，但只有terminate那几行有差异，前面的都相同，原因是当主线程发出通知结束线程事件后，各线程突然跳出，而且无顺序的跳出，线程中等待的时间也有差异，导致这样的结果。