Compartir tecnología

Programación principal de WIN32: operación de subprocesos (2) Exclusión mutua sincrónica

2024-07-12

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

Tabla de contenido

condición de carrera

Sección crítica

Mutex

Sección crítica y mutex

Semáforo

Eventoo

condición de carrera

  • En un entorno de subprocesos múltiples, cuando varios subprocesos acceden o modifican los mismos datos al mismo tiempo, el resultado final es el tiempo de ejecución del subproceso.

  • Si no existe un mecanismo de sincronización, se producirán condiciones de carrera, lo que puede provocar datos inexactos o excepciones del programa.

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

Sección crítica

  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) se utiliza para evitar que varios subprocesos accedan o modifiquen recursos compartidos al mismo tiempo.

  • Solo un subproceso puede poseer el mutex al mismo tiempo. Si un subproceso toma posesión del mutex, otros subprocesos que soliciten el mutex se bloquearán hasta que se libere el permiso del mutex.

  • Crear un mutex - CreateMutex

  • Solicitar exclusión mutua: WaitForSingleObject

  • Liberar el 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. }

Sección crítica y mutex

  • sección crítica

    • Mecanismo de sincronización de subprocesos para recursos compartidos, las secciones críticas proporcionan acceso mutuamente exclusivo entre subprocesos del mismo proceso.

    • Cada subproceso debe poder ingresar a la sección crítica antes de acceder a los recursos compartidos y salir de la sección crítica después de completar el acceso para completar la sincronización del subproceso.

  • exclusión mutua

    • El mecanismo de sincronización de subprocesos se utiliza para restringir el acceso de varios subprocesos a recursos compartidos al mismo tiempo.

    • Los mutex pueden sincronizar procesos o subprocesos y pueden sincronizarse entre procesos.
      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. }

  • actuación

    • Las secciones críticas son más rápidas que las exclusiones mutuas dentro de subprocesos del mismo proceso.

  • Función

    • Los mutex se pueden sincronizar entre procesos, pero las secciones críticas solo se pueden sincronizar entre subprocesos del mismo proceso.

  • propiedad

    • Los mutex tienen estrictos requisitos de propiedad y solo los subprocesos con permisos mutex pueden liberarlos.

  • punto muerto
    • Cuando un hilo muere inesperadamente mientras mantiene un candado (excepción)
    • Si un subproceso termina inesperadamente mientras mantiene un bloqueo de sección crítica, el bloqueo no se liberará, lo que provocará que otros subprocesos que esperan la sección crítica no puedan ejecutarse normalmente, lo que resulta en un punto muerto.
      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 un subproceso termina inesperadamente mientras mantiene un bloqueo mutex, Windows libera automáticamente su propiedad para que otros subprocesos puedan continuar ejecutándose normalmente.
      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. }

Semáforo

  • Un semáforo es un objeto de sincronización que se utiliza para controlar el acceso a recursos compartidos por parte de múltiples subprocesos. Es un contador que representa la cantidad de recursos disponibles. Cuando el valor del semáforo es mayor que 0, indica que hay recursos disponibles; cuando el valor es 0, indica que no hay recursos disponibles.

    • esperar : Intenta disminuir el valor del semáforo. Si el valor del semáforo es mayor que 0, disminúyalo en 1 y continúe la ejecución. Si el valor del semáforo es 0, el hilo se bloquea hasta que el valor del semáforo sea mayor que 0.

    • liberado : Aumenta el valor del semáforo. Si hay otros hilos bloqueados esperando este semáforo, uno de ellos se despertará.

  • Crear semáforo

    • En sistemas Windows, utilice CreateSemaphore oCreateSemaphoreEx La función crea un semáforo.

  • Espere (Esperar) y suelte (Liberar) el semáforo

    • La espera de un semáforo generalmente se realiza usando WaitForSingleObject oWaitForMultipleObjects función.

    • Liberar el uso del semáforo ReleaseSemaphore función.

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

Eventoo

  • En la programación de Windows, los eventos son un mecanismo de sincronización que se utiliza para enviar señales entre múltiples subprocesos.El objeto del evento puede serreinicio manualoreinicio automático。

    • Evento de reinicio manual: cuando se establece (señala) un evento, permanecerá en este estado hasta que se reinicie explícitamente. Esto significa que se pueden activar varios subprocesos que esperan el evento antes de que se restablezca el evento.

    • Evento de reinicio automático: cuando un hilo en espera recibe (señala) un evento, el sistema restablece automáticamente el estado del evento a no señalizado (sin señalizar). Esto significa que sólo se permite activar un hilo a la vez.

  • Crear evento

    • Uso de funciones API de WindowsCreateEventSe puede crear un objeto de evento.

    • lpEventAttributes: Puntero al atributo de seguridad, si está configurado enNULL, se utiliza la seguridad predeterminada.

    • bManualReset: siTRUE, se crea un evento de reinicio manual; de lo contrario, se crea un evento de reinicio automático.

    • bInitialState: siTRUE, entonces el estado inicial es el estado de la señal si;FALSE, es un estado de no señalización.

    • lpName: El nombre del evento.

  • Para configurar un evento (establecer el estado del evento al estado de la señal) useSetEventfunción

  • Para restablecer un evento (establecer el estado del evento en un estado no señalizado) utiliceResetEventfunción

  • Espere a que el evento espere a que un objeto de evento se convierta en un estado de señal.WaitForSingleObjectfunción

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

Perfil personal

Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi informacion de contacto

Correo