Technology sharing

WIN32 Core Programming - Thread Operation (2) Synchroni Mutua Exclusio

2024-07-12

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

Tabula contentorum

genus conditio

CriticalSection

Mutex

CriticalSection & Mutex

Semaphore

Eventusus

genus conditio

  • In ambitu multi-filato, cum plures filis eadem notitia simul accessere vel mutare, ultimus effectus est sequela temporis exsecutionis.

  • Si nulla est synchronisatio mechanismi, condiciones generis occurrent, quae ad improprias notitias vel exceptiones programmatis adducere possunt.

  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 (Mutex) adhibetur ne plures fila ab accessu vel diminutione facultatum communium simul sint.

  • Tantum unum linum simul habere potest mutex. Si unum filum obtinet dominium mutex, alia stamina petens mutex obstruetur donec permissio mutex dimittatur.

  • Mutex creare - CreateMutex

  • Request Mutex - WaitForSingleObject

  • Mutex dimitte - 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

  • discrimine sectionem

    • Sequela synchronisatio mechanismi pro facultatibus communibus, sectiones criticae mutuae accessum inter fila eiusdem processus praebent.

    • Singula fila debebunt sectionem criticam ingredi antequam facultates communes accesserint, et sectionem criticam relinquant postquam accessus ad summam synchronizationem filorum perficiatur.

  • mutex

    • Mechanismus sequela synchronisatio ad fila multiplices restringere adhibetur ab accessu facultatum communium simul.

    • Mutexes processus vel fila synchronizare possunt, et per processum synchronizari possunt.
      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. }

  • perficientur

    • Sectiones criticae velociores sunt quam mutices intra fila eiusdem processus.

  • Officium

    • Mutexes trans processuum synchronizari possunt, sectiones autem criticae tantum inter fila in eodem processu congruere possunt.

  • dominium

    • Mutexes stricte dominii requisita habent et solum sequela cum permissionibus mutexis possunt eam dimittere.

  • deadlock
    • Cum filum subito moritur dum seram tenens (exceptio)
    • Si linum inopinate terminetur dum seram criticam tenentes, seram non solvetur, cum alia fila exspectant sectionem criticam ut normaliter exequi non possint, in deadlock resultantes.
      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. }
    • Si filum subito dum mutex crinem tenens terminatur, Fenestra automatice dominium suum emittit ut alia stamina regulariter exercere possint.
      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

  • Semaphora est obiectum synchronisation usus ad refrenandum accessum ad facultates per plures fila participandas. Contrarium est quod quantitatem facultatum suppeditarum repraesentat. Cum valor semaphoris maior quam 0 est, indicat facultates praesto esse; cum valor 0 est, indicat nullas esse facultates.

    • manere : Deminuere conatus semaphori valoris. Si valorem semaphoris maior est quam 0, decrementum illud per 1 et executionem continuabit. Si valorem semaphoris 0 est, stamina praecluduntur donec valorem semaphoris maior quam 0 fiat.

    • liberatus : valorem semaphoris auge. Si alia stamina inclusa sunt, hoc semaphoro exspectantes, una ex illis excitabitur.

  • Create semaphore

    • In Fenestra systemata, utere CreateSemaphore or *CreateSemaphoreEx Munus semaphore creat.

  • Exspecta (exspecta) et emissio (Release) semaphore

    • Exspectans in semaphore fieri solet uti WaitForSingleObject or *WaitForMultipleObjects officium.

    • Dimittere semaphore usus ReleaseSemaphore officium.

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

Eventusus

  • In programmatione Fenestra, eventus synchronismi sunt mechanismum adhibitum ut signa mittant inter plures stamina.Res potest essemanual resetor *automatic reset。

    • Manual Reset Event: Cum eventum (signatum) manebit in hoc statu donec explicite reset. Id significat multa fila exspectantia eventum posse ante eventum reseti excitari.

    • Auto Reset Event: Cum eventus filo exspectante acceptus est, ratio automatice eventui civitatis ad non-signatum (non-signatum) reponit. Hoc significat tantum unum filum ad tempus excitari licere.

  • Create eventu

    • Utens Fenestra API muneraCreateEventAn res creata potest

    • lpEventAttributes: Indicium securitati attributum, si toNULL, pignus adhibetur.

    • bManualReset: siTRUE, dein eventus manualis retexere creatur, alioquin eventus latis rete creatum est.

    • bInitialState: siTRUEstatus initialis est status signum;FALSEest status non significativus.

    • lpName: nomen rei.

  • Ad rem (statuto rei publicae statum insignem) ususSetEventofficium

  • Reset ad res (set res publica ad res publica non-signatum) ususResetEventofficium

  • Exspectare eventum expectare rei eventum rei publicae signum fieri.WaitForSingleObjectofficium

  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

technologiae technologiae plus quam 30 annos operam dedit et in variis linguis proficit ut java, linux, javascript, php, css, etc. Multas contributiones in aperto fonte campo fecit elit documentorum statione ad communicandas quaestiones technologiarum progressus ad futuram referentiam

mihi contactus notitia

Mail