Technology Sharing

WIN32 Core Programming - Thread Operation (II) Synchronization and Mutual Exclusion

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Table of contents

Race Conditions

CriticalSection

Mutex

CriticalSection & Mutex

Semaphore

Event

Race Conditions

  • In a multi-threaded environment, when multiple threads access or modify the same data at the same time, the final result is the execution time of the threads.

  • If there is no synchronization mechanism, race conditions will occur, which may cause inaccurate data or program exceptions.

  1. #include <iostream>
  2. #include <windows.h>
  3.  
  4. DWORD g_Num = 0;
  5.  
  6. DWORD WINAPI WorkThread(LPVOID lp)
  7. {
  8.     for (size_t i = 0; i < 10000000; i++)
  9.     {
  10.         //g_Num++;
  11.         __asm LOCK INC [g_Num] 
  12.     }
  13.     return 0;
  14. }
  15.  
  16. int main()
  17. {
  18.     HANDLE hThread[2] = { 0 };
  19.     hThread[0] = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
  20.     hThread[1] = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
  21.     WaitForMultipleObjects(2, hThread, TRUE, -1);
  22.     std::cout << g_Num << std::endl;
  23.  
  24.     return 0;
  25. }

CriticalSection

  1. #include <iostream>
  2. #include <windows.h>
  3.  
  4. DWORD g_Num = 0;
  5. CRITICAL_SECTION cs = { 0 };
  6.  
  7. DWORD WINAPI WorkThread(LPVOID lp)
  8. {
  9. 	for (size_t i = 0; i < 1000000; i++)
  10. 	{
  11. 		// 进入临界区
  12. 		EnterCriticalSection(&cs);
  13.  
  14. 		// TODO
  15. 		g_Num++;
  16.  
  17. 		// 退出临界区
  18. 		LeaveCriticalSection(&cs);
  19. 	}
  20. 	return 0;
  21. }
  22.  
  23. int main()
  24. {
  25.  
  26. 	HANDLE hThread[2] = { 0 };
  27. 	// 初始临界区
  28. 	InitializeCriticalSection(&cs);
  29.  
  30. 	hThread[0] = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
  31. 	hThread[1] = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
  32.  
  33. 	WaitForMultipleObjects(2, hThread, TRUE, -1);
  34.  
  35. 	std::cout << g_Num << std::endl;
  36.  
  37. 	// 清理临界区
  38. 	DeleteCriticalSection(&cs);
  39.  
  40. 	return 0;
  41. }

Mutex

  • Mutex is used to prevent multiple threads from accessing or modifying shared resources at the same time.

  • Only one thread can own a mutex at the same time. If a thread owns a mutex, other threads requesting the mutex will be blocked until the mutex permission is released.

  • Create a mutex - CreateMutex

  • Requesting a mutex - WaitForSingleObject

  • Release Mutex - ReleaseMutex

  1. #include <iostream>
  2. #include <windows.h>
  3.  
  4. HANDLE hMutex = 0;
  5. DWORD g_Num = 0;
  6.  
  7. DWORD WINAPI WorkThread(LPVOID lp)
  8. {
  9. 	for (size_t i = 0; i < 100000; i++)
  10. 	{
  11. 		WaitForSingleObject(hMutex, INFINITE);
  12. 		g_Num++;
  13. 		ReleaseMutex(hMutex);
  14. 	}
  15.  
  16. 	return 0;
  17. }
  18.  
  19. int main()
  20. {
  21. 	hMutex = CreateMutex(NULL, FALSE, NULL); 
  22.  
  23. 	HANDLE hThread1 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
  24. 	HANDLE hThread2 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
  25.  
  26. 	WaitForSingleObject(hThread1, INFINITE);
  27. 	WaitForSingleObject(hThread2, INFINITE);
  28.  
  29. 	CloseHandle(hThread1);
  30. 	CloseHandle(hThread2);
  31. 	CloseHandle(hMutex);
  32. 	
  33. 	std::cout << g_Num << std::endl;
  34.  
  35. 	return 0;
  36. }

CriticalSection & Mutex

  • Critical Section

    • A thread synchronization mechanism for shared resources, critical sections provide mutually exclusive access between threads in the same process.

    • Each thread must be able to enter the critical section before accessing shared resources and leave the critical section after the access is completed to complete thread synchronization.

  • Mutex

    • Thread synchronization mechanism is used to limit multiple threads from accessing shared resources at the same time.

    • Mutexes can synchronize processes or threads, and can synchronize across processes.
      1. #include <iostream>
      2. #include <Windows.h>
      3.  
      4. int main()
      5. {
      6. 	HANDLE hMutex = CreateMutex(NULL, FALSE, L"0xCC_Mutex");
      7. 	if (hMutex == NULL) return 0;
      8. 	if (GetLastError() == ERROR_ALREADY_EXISTS)
      9. 	{
      10. 		MessageBox(NULL, L"禁止多开", L"错误", MB_OKCANCEL);
      11. 		return 0;
      12. 	}
      13. 	std::cout << "Game Start..." << std::endl;
      14. 	system("pause");
      15. 	CloseHandle(hMutex);
      16. 	return 0;
      17. }

  • performance

    • Critical sections are faster than mutexes within threads of the same process.

  • Function

    • Mutexes can be synchronized across processes, but critical sections can only be synchronized between threads in the same process.

  • ownership

    • Mutexes have strict ownership requirements; only the thread that holds the mutex can release it.

  • Deadlock
    • When a thread dies unexpectedly while holding a lock (Exception)
    • If a thread terminates unexpectedly while holding a critical section lock, the lock will not be released, causing other threads waiting for the critical section to fail to execute normally, resulting in a deadlock.
      1. #include <iostream>
      2. #include <Windows.h>
      3.  
      4. CRITICAL_SECTION CriticalSection = { 0 };
      5.  
      6. DWORD WINAPI WorkThread(LPVOID lp)
      7. {
      8. 	EnterCriticalSection(&CriticalSection);
      9. 	
      10. 	printf("TID -> %d rn", GetCurrentThreadId());
      11. 	Sleep(5000);
      12.  
      13. 	LeaveCriticalSection(&CriticalSection);
      14.  
      15. 	return 0;
      16. }
      17.  
      18. int main()
      19. {
      20. 	InitializeCriticalSection(&CriticalSection);
      21.  
      22. 	HANDLE hThread1 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
      23. 	Sleep(1000);
      24. 	TerminateThread(hThread1, 1);
      25.  
      26. 	HANDLE hThread2 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
      27. 	WaitForSingleObject(hThread2, INFINITE);
      28.  
      29. 	DeleteCriticalSection(&CriticalSection);
      30.  
      31. 	return 0;
      32. }
    • If a thread unexpectedly terminates while holding a mutex lock, Windows automatically releases its ownership, allowing other threads to continue executing normally.
      1. #include <iostream>
      2. #include <Windows.h>
      3.  
      4. HANDLE hMutex = NULL;
      5.  
      6. DWORD WINAPI WorkThread1(LPVOID lp)
      7. {
      8. 	WaitForSingleObject(hMutex, INFINITE);
      9. 	printf("TID -> %d rn", GetCurrentThreadId());
      10. 	Sleep(5000);
      11. 	TerminateThread(GetCurrentThread(), -1);
      12.  
      13. 	//todo
      14. 	return 0;
      15. }
      16.  
      17. DWORD WINAPI WorkThread2(LPVOID lp)
      18. {
      19. 	printf("Wait For Thread1 Leavern");
      20. 	WaitForSingleObject(hMutex, INFINITE);
      21. 	printf("TID -> %d rn", GetCurrentThreadId());
      22. 	ReleaseMutex(hMutex);
      23. 	return 0;
      24. }
      25.  
      26.  
      27. int main()
      28. {
      29. 	hMutex = CreateMutex(NULL, FALSE, NULL);
      30.  
      31. 	HANDLE hThread1 = CreateThread(NULL, 0, WorkThread1, NULL, 0, NULL);
      32. 	Sleep(1000);
      33.  
      34. 	HANDLE hThread2 = CreateThread(NULL, 0, WorkThread2, NULL, 0, NULL);
      35. 	WaitForSingleObject(hThread2, INFINITE);
      36.  
      37. 	CloseHandle(hMutex);
      38. 	CloseHandle(hThread1);
      39. 	CloseHandle(hThread2);
      40.  
      41. 	return 0;
      42. }

Semaphore

  • A semaphore is a synchronization object used to control the access of multiple threads to shared resources. It is a counter that indicates the number of available resources. When the value of the semaphore is greater than 0, it indicates that resources are available; when the value is 0, it indicates that no resources are available.

    • wait: Try to decrease the value of the semaphore. If the value of the semaphore is greater than 0, decrement 1 and continue execution. If the value of the semaphore is 0, the thread blocks until the value of the semaphore becomes greater than 0.

    • freed: Increase the value of the semaphore. If there are other threads blocked waiting for this semaphore, one of them will be woken up.

  • Creating a Semaphore

    • On Windows, use CreateSemaphore orCreateSemaphoreEx The function creates a semaphore.

  • Waiting and releasing semaphores

    • Waiting for a semaphore is usually done using WaitForSingleObject orWaitForMultipleObjects function.

    • Release semaphore using ReleaseSemaphore function.

  1. #include <iostream>
  2. #include <Windows.h>
  3.  
  4. #define MAX_COUNT_SEMAPHORE 3
  5.  
  6.  
  7. HANDLE g_SemapHore = NULL;
  8. HANDLE g_hThreadArr[10] = { 0 };
  9.  
  10. DWORD WINAPI WorkThread(LPVOID lp)
  11. {
  12. 	WaitForSingleObject(g_SemapHore, INFINITE);
  13.  
  14. 	for (size_t i = 0; i < 10; i++)
  15. 	{
  16. 		std::cout << "COUNT -> " << (int)lp << std::endl;
  17. 		Sleep(500);
  18. 	}
  19.  
  20. 	ReleaseSemaphore(g_SemapHore, 1, NULL);
  21.  
  22. 	return 0;
  23. }
  24.  
  25. int main()
  26. {
  27. 	g_SemapHore = CreateSemaphore(
  28. 		NULL,						//安全属性
  29. 		MAX_COUNT_SEMAPHORE,		//初始计数
  30. 		MAX_COUNT_SEMAPHORE,		//最大计数
  31. 		NULL						//信号名称
  32. 	);
  33. 	
  34. 	if (g_SemapHore == NULL)
  35. 	{
  36. 		std::cout << GetLastError() << std::endl;
  37. 		return 1;
  38. 	}
  39.  
  40. 	for (size_t i = 0; i < 10; i++)
  41. 	{
  42. 		g_hThreadArr[i] = CreateThread(
  43. 			NULL,
  44. 			0,
  45. 			WorkThread,
  46. 			(LPVOID)i,
  47. 			0,
  48. 			NULL
  49. 		);
  50. 	}
  51. 	
  52. 	WaitForMultipleObjects(10, g_hThreadArr, TRUE, INFINITE);
  53. 	
  54. 	//closehandle
  55.  
  56. 	return 0;
  57. }

Event

  • In Windows programming, an event is a synchronization mechanism used to send signals between multiple threads. An event object can beManual ResetorAutomatic reset。

    • Manual Reset Event: Once an event is signaled, it will remain in this state until it is explicitly reset. This means that multiple threads waiting on the event can be woken up before the event is reset.

    • Auto Reset Event: When an event is received (signaled) by a waiting thread, the system automatically resets the event state to non-signaled. This means that only one thread is allowed to be woken up at a time.

  • Create an event

    • Using Windows API FunctionsCreateEventYou can create an event object

    • lpEventAttributes: Pointer to security attributes. If set toNULL, the default security is used.

    • bManualReset：IfTRUE, a manual reset event is created, otherwise an automatic reset event is created.

    • bInitialState：IfTRUE, the initial state is the signal state; ifFALSE, it is a non-signal state.

    • lpName: The name of the event.

  • To set an event (set the event state to the signaled state) useSetEventfunction

  • To reset an event (set the event state to a non-signaled state) useResetEventfunction

  • Wait for an event to become a signaled state.WaitForSingleObjectfunction

  1. #include <iostream>
  2. #include <Windows.h>
  3.  
  4. DWORD WINAPI WorkThread(LPVOID lp)
  5. {
  6. 	HANDLE hEvent = *(HANDLE*)lp;
  7. 	std::cout << "Thread - " << GetCurrentThreadId() << " Waiting For Event" << std::endl;
  8. 	WaitForSingleObject(hEvent, INFINITE);
  9. 	std::cout << "Thread - " << GetCurrentThreadId() << " actived" << std::endl;
  10. 	return 0;
  11. }
  12.  
  13. int main()
  14. {
  15. 	HANDLE hThreads[3] = { 0 };
  16. 	HANDLE hEvent = NULL;
  17.  
  18. 	hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  19. 	if (hEvent == NULL) return 0;
  20.  
  21. 	for (size_t i = 0; i < 3; i++)
  22. 	{
  23. 		hThreads[i] = CreateThread(NULL, 0, WorkThread, &hEvent, 0, NULL);
  24. 	}
  25.  
  26. 	Sleep(2000);
  27. 	SetEvent(hEvent);
  28. 	
  29. 	WaitForMultipleObjects(3, hThreads, TRUE, INFINITE);
  30.  
  31. 	CloseHandle(hEvent);
  32.  
  33. 	return 0;
  34. }

Personal profile

I have devoted myself to the research of technology for more than 30 years. I am proficient in various languages ​​such as Java, Linux, JavaScript, PHP, CSS, etc. I have made many contributions in the field of open source. I have established a developer documentation site to share some problems in technology development for everyone to read.

my contact information

Mail