技术共享

WIN32核心编程 - 线程操作(二) 同步互斥

2024-07-12

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

目录

竞态条件

CriticalSection

Mutex

CriticalSection & Mutex

Semaphore

Event

竞态条件

  • 多线程环境下，当多个线程同时访问或者修改同一个数据时，最终结果为线程执行的时许。

  • 如果没有同步机制，会发生竞态条件，可能导致数据不准确，或者程序发生异常等。

  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)，用于防止多个线程同时访问或修改共享资源。

  • 同一时刻下只有一个线程可以拥有互斥体的所有权，如果一个线程拥有了互斥体的所有权，则其他请求该互斥体的线程将会被阻塞，直到互斥体权限释放。

  • 创建互斥体 - CreateMutex

  • 请求互斥体 - WaitForSingleObject

  • 释放互斥体 - 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

  • 临界区

    • 共享资源的线程同步机制，临界区在同一进程的线程之间提供了互斥访问。

    • 每个线程在访问共享资源之前必须先能够进入临界区，在访问结束后离开临界区，完成线程同步。

  • 互斥体

    • 线程同步机制，用来限制多个线程同时访问共享资源。

    • 互斥体可以同步进程或者线程，且可以跨进程同步。
      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. }

  • 性能

    • 临界区在同一进程的线程中比互斥体更快。

  • 功能

    • 互斥体可以跨进程同步，但临界区只能够在同一个进程下的线程之间进行同步。

  • 所有权

    • 互斥体有严格的所有权要求，只有拥有互斥体权限的线程才能够释放它。

  • 死锁
    • 当线程在持有锁的情况下意外死亡(异常)
    • 如果线程在持有临界区锁的情况下意外终结，这个锁不会被释放，导致其他等待该临界区的线程无法正常执行，造成死锁。
      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. }
    • 如果线程在持有互斥体锁的情况下意外终结，Windows会自动释放其所有权，使得其他线程可以继续正常执行。
      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

  • 信号量是一种同步对象，用于控制多个线程对共享资源的访问。它是一个计数器，用来表示可用资源的数量。当信号量的值大于0，它表示有资源可用；当值为0，表示没有可用资源。

    • 等待：试图减少信号量的值。如果信号量的值大于0，减1并继续执行。如果信号量的值为0，则线程阻塞，直到信号量的值变为大于0。

    • 释放：增加信号量的值。如果有其他线程因等待这个信号量而阻塞，它们中的一个将被唤醒。

  • 创建信号量

    • 在 Windows 系统中，使用 CreateSemaphore 或 CreateSemaphoreEx 函数创建信号量。

  • 等待（Wait）和释放（Release）信号量

    • 等待信号量通常使用 WaitForSingleObject 或 WaitForMultipleObjects 函数。

    • 释放信号量使用 ReleaseSemaphore 函数。

  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

  • 在Windows编程中，事件是一种同步机制，用于在多个线程之间发送信号。事件对象可以是手动重置或自动重置。

    • 手动重置事件（Manual Reset Event）：当事件被设置（signaled）后，它将保持这个状态直到显式地被重置。这意味着多个等待该事件的线程都可以在事件被重置之前被唤醒。

    • 自动重置事件（Auto Reset Event）：当事件被一个等待的线程接收（signaled）后，系统会自动将事件状态重置为非信号状态（non-signaled）。这意味着每次只允许一个线程被唤醒。

  • 创建事件

    • 使用Windows API函数CreateEvent可以创建一个事件对象

    • lpEventAttributes：指向安全属性的指针，如果设置为NULL，则使用默认安全性。

    • bManualReset：如果为TRUE，则创建一个手动重置事件，否则创建自动重置事件。

    • bInitialState：如果为TRUE，则初始状态为信号状态；如果为FALSE，则为非信号状态。

    • lpName：事件的名称。

  • 设置事件（将事件状态设置为信号状态）使用SetEvent函数

  • 重置事件（将事件状态设置为非信号状态）使用ResetEvent函数

  • 等待事件 等待一个事件对象变为信号状态使用WaitForSingleObject函数

  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. }

个人简介

潜心研究技术三十余年，精通java、linux、javascript、php、css、等等各种语言，在开源领域有诸多贡献，建立开发者文档站，将一些技术开发中的问题分享出来，以供大家查阅

我的联系方式

邮箱