win32线程同步5大方案例程--_beginthreadex

转自：http://download.csdn.net/down/2887013/virgil0236

 

//线程同步-互斥量
#include <Windows.h>
#include <process.h>
#include <iostream>
using namespace std;

const int  G_THREAD_INSTANCE_NUMBER = 3;

unsigned __stdcall ThreadProc(LPVOID pData);

int main()
{
 unsigned ID[G_THREAD_INSTANCE_NUMBER];
 HANDLE h[G_THREAD_INSTANCE_NUMBER];
 HANDLE hMutex;

 hMutex = CreateMutex(NULL, FALSE, TEXT("MutexTest"));
 if(!hMutex) {
  cout << "Create Mutex error!" << endl;
  return 0;
 }

 for(int i = 0; i < G_THREAD_INSTANCE_NUMBER; ++i) {
  h[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc, (void*)&ID[i], 0, &(ID[i])); 
  Sleep(1000);
 }

 WaitForMultipleObjects(G_THREAD_INSTANCE_NUMBER, h, TRUE, INFINITE);
 for(int i = 0; i < G_THREAD_INSTANCE_NUMBER; ++i){
  CloseHandle(h[i]);
 }
 cout << "Close the mutex handle!" << endl;
 CloseHandle(hMutex);
}

unsigned __stdcall ThreadProc(LPVOID pData)
{
 int nThreadNumberTemp = (*(int*)pData);
 HANDLE hMutex;

 cout << "ThreadProc:" << nThreadNumberTemp << "is running!" << endl;
 hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, TEXT("MutexTest"));
 if(!hMutex) {
  cout << "Open Mutex error!" << endl;
 }
 else {
  cout << "ThreadProc" << nThreadNumberTemp << "gets the mutex/n" << endl;
  ReleaseMutex(hMutex);
 }

 CloseHandle(hMutex);
 return 0;
}

//线程同步-临界区
#include <Windows.h>
#include <process.h>
#include <iostream>
using namespace std;

int g_total = 100;
HANDLE g_evFin[2];
CRITICAL_SECTION cs;

unsigned __stdcall WithdrawThread1(LPVOID param);
unsigned __stdcall WithdrawThread2(LPVOID param);

int main()
{
 g_evFin[0] = CreateEvent(NULL, FALSE, FALSE, NULL);
 g_evFin[1] = CreateEvent(NULL, FALSE, FALSE, NULL);
 
 HANDLE handle1;
 HANDLE handle2;

 InitializeCriticalSection(&cs);
 handle1 = (HANDLE)_beginthreadex(NULL, 0, WithdrawThread1, NULL, 0, NULL);
 handle2 = (HANDLE)_beginthreadex(NULL, 0, WithdrawThread2, NULL, 0, NULL);
 
 WaitForMultipleObjects(2, g_evFin, TRUE, INFINITE);
 cout << g_total << endl;

 DeleteCriticalSection(&cs);
 CloseHandle(g_evFin[0]);
 CloseHandle(g_evFin[1]);
 CloseHandle(handle1);
 CloseHandle(handle2);
}

unsigned __stdcall WithdrawThread1(LPVOID param)
{
 EnterCriticalSection(&cs);

 if(g_total-90 >= 0) {
  g_total -= 90;
  cout << "You withdraw 90" << endl;
 }
 else
  cout << "You do not have that much money" << endl;

 LeaveCriticalSection(&cs);
 SetEvent(g_evFin[0]);
 return 0;
}

unsigned __stdcall WithdrawThread2(LPVOID param)
{
 EnterCriticalSection(&cs);

 if(g_total-20 >= 0) {
  g_total -= 20;
  cout << "You withdraw 20" << endl;
 }
 else
  cout << "You do not have that much money" << endl;

 LeaveCriticalSection(&cs);

 SetEvent(g_evFin[1]);
 return 0;
}

 

//线程同步-全局变量
//该方法不安全！只为演示用
#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;

bool g_bVal = false;

unsigned __stdcall ThreadFunc(LPVOID pParam);

int main()
{
 HANDLE handle = (HANDLE)_beginthreadex(NULL, 0, ThreadFunc, NULL, 0, NULL);
 if(!handle) {
  cout << "Thread create error!" << endl;
  CloseHandle(handle);
 }
 
 while(!g_bVal)
  cout << "Thread while" << endl;
 cout << "thread exit" << endl;
 
 CloseHandle(handle);
}

unsigned __stdcall ThreadFunc(LPVOID pParam)
{
 cout << "ThreadFunc" << endl;
 Sleep(200);
 g_bVal = true;
 return 0;
}

 

//线程同步-事件
#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;

HANDLE evRead;
HANDLE evFinish;

unsigned __stdcall ReadThread(LPVOID param);
unsigned __stdcall WINAPI WriteThread(LPVOID param);

int main()
{
 evRead = CreateEvent(NULL, FALSE, FALSE, NULL);
 evFinish = CreateEvent(NULL, FALSE, FALSE, NULL);
 
 HANDLE handle1;
 HANDLE handle2;
 handle1 = (HANDLE)_beginthreadex(NULL, 0, ReadThread, NULL, 0, NULL);
 handle2 = (HANDLE)_beginthreadex(NULL, 0, WriteThread, NULL, 0, NULL);

 WaitForSingleObject(evFinish, INFINITE);
 cout << "The program is end" << endl;

 CloseHandle(handle1);
 CloseHandle(handle2);
 CloseHandle(evRead);
 CloseHandle(evFinish);
}

unsigned __stdcall ReadThread(LPVOID param)
{
 WaitForSingleObject(evRead, INFINITE);
 cout << "Reading" << endl;
 SetEvent(evFinish);

 return 0;
}

unsigned __stdcall WriteThread(LPVOID param)
{
 cout << "Writing" << endl;
 SetEvent(evRead);

 return 0;
}

 

//线程同步-信号量
#include <windows.h>
#include <process.h>
#include <iostream>
using namespace std;

#define THREAD_INSTANCE_NUMBER 3
unsigned __stdcall foo(void* pData);

int main()
{
 unsigned nThreadID[THREAD_INSTANCE_NUMBER];
 HANDLE threads[THREAD_INSTANCE_NUMBER];
 HANDLE hSemaphore;

 hSemaphore = CreateSemaphore(NULL, 0, 1, TEXT("Semaphore.Test"));
 if(!hSemaphore) {
  cout << "Create semaphore error!" << endl;
  return 0;
 }

 for(int i = 0; i < THREAD_INSTANCE_NUMBER; ++i) {
  threads[i] = (HANDLE)_beginthreadex(NULL, 0, foo, (void*)&nThreadID[i], 0, &(nThreadID[i]));
  Sleep(1000);
 }

 WaitForMultipleObjects(THREAD_INSTANCE_NUMBER, (HANDLE*)threads, TRUE, INFINITE);
 cout << "Close the semaphore handle!" << endl;

 for(int i = 0; i < THREAD_INSTANCE_NUMBER; ++i)
  CloseHandle(threads[i]);
 CloseHandle(hSemaphore);
}

unsigned __stdcall foo(void* pData)
{
 int nThreadNumberTemp = (*(int*)pData);
 HANDLE hSemaphore;

 cout << "foo:" << nThreadNumberTemp << "is running!" << endl;
 hSemaphore = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, TEXT("Semaphore.Test"));
 if(!hSemaphore)
  cout << "Open semaphore error!" << endl;
 cout << "foo" << nThreadNumberTemp << "gets the semaphore/n" << endl;
 ReleaseSemaphore(hSemaphore, 1, NULL);
 CloseHandle(hSemaphore);

 return 0;
}