Обмен технологиями

Базовое программирование WIN32 — потоковые операции (2) Синхронное взаимное исключение

2024-07-12

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

Оглавление

состояние гонки

КритическийРаздел

Мьютекс

Критическая секция и мьютекс

Семафор

Событие


состояние гонки

  • В многопоточной среде, когда несколько потоков одновременно обращаются к одним и тем же данным или изменяют их, конечным результатом является время выполнения потока.

  • Если механизм синхронизации отсутствует, возникнут состояния гонки, что может привести к неточным данным или программным исключениям.

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

КритическийРаздел

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

Мьютекс

  • Мьютекс (Mutex) используется для предотвращения одновременного доступа нескольких потоков к общим ресурсам или их изменения.

  • Одновременно только один поток может владеть мьютексом. Если один поток становится владельцем мьютекса, другие потоки, запрашивающие мьютекс, будут заблокированы до тех пор, пока не будет освобождено разрешение мьютекса.

  • Создать мьютекс — CreateMutex

  • Запросить мьютекс — WaitForSingleObject

  • Освободить мьютекс — ReleaseMutex

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

Критическая секция и мьютекс

  • критическая секция

    • Механизм синхронизации потоков для общих ресурсов, критические секции обеспечивают взаимоисключающий доступ между потоками одного и того же процесса.

    • Каждый поток должен иметь возможность войти в критический раздел перед доступом к общим ресурсам и покинуть критический раздел после завершения доступа для завершения синхронизации потоков.

  • мьютекс

    • Механизм синхронизации потоков используется для ограничения одновременного доступа нескольких потоков к общим ресурсам.

    • Мьютексы могут синхронизировать процессы или потоки, а также синхронизировать их между процессами.
      1. #include <iostream>
      2. #include <Windows.h>
      3. int main()
      4. {
      5. HANDLE hMutex = CreateMutex(NULL, FALSE, L"0xCC_Mutex");
      6. if (hMutex == NULL) return 0;
      7. if (GetLastError() == ERROR_ALREADY_EXISTS)
      8. {
      9. MessageBox(NULL, L"禁止多开", L"错误", MB_OKCANCEL);
      10. return 0;
      11. }
      12. std::cout << "Game Start..." << std::endl;
      13. system("pause");
      14. CloseHandle(hMutex);
      15. return 0;
      16. }
  • производительность

    • Критические секции работают быстрее, чем мьютексы внутри потоков одного и того же процесса.

  • Функция

    • Мьютексы можно синхронизировать между процессами, но критические секции можно синхронизировать только между потоками одного и того же процесса.

  • владение

    • Мьютексы имеют строгие требования к владению, и только потоки с разрешениями на мьютексы могут освободить их.

  • тупик
    • Когда поток неожиданно завершает работу во время удержания блокировки (исключение)
    • Если поток неожиданно завершается, удерживая блокировку критической секции, блокировка не будет снята, в результате чего другие потоки, ожидающие критической секции, не смогут нормально выполняться, что приведет к взаимоблокировке.
      1. #include <iostream>
      2. #include <Windows.h>
      3. CRITICAL_SECTION CriticalSection = { 0 };
      4. DWORD WINAPI WorkThread(LPVOID lp)
      5. {
      6. EnterCriticalSection(&CriticalSection);
      7. printf("TID -> %d rn", GetCurrentThreadId());
      8. Sleep(5000);
      9. LeaveCriticalSection(&CriticalSection);
      10. return 0;
      11. }
      12. int main()
      13. {
      14. InitializeCriticalSection(&CriticalSection);
      15. HANDLE hThread1 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
      16. Sleep(1000);
      17. TerminateThread(hThread1, 1);
      18. HANDLE hThread2 = CreateThread(NULL, 0, WorkThread, NULL, 0, NULL);
      19. WaitForSingleObject(hThread2, INFINITE);
      20. DeleteCriticalSection(&CriticalSection);
      21. return 0;
      22. }
    • Если поток неожиданно завершается, удерживая блокировку мьютекса, Windows автоматически освобождает его владение, чтобы другие потоки могли продолжать нормальное выполнение.
      1. #include <iostream>
      2. #include <Windows.h>
      3. HANDLE hMutex = NULL;
      4. DWORD WINAPI WorkThread1(LPVOID lp)
      5. {
      6. WaitForSingleObject(hMutex, INFINITE);
      7. printf("TID -> %d rn", GetCurrentThreadId());
      8. Sleep(5000);
      9. TerminateThread(GetCurrentThread(), -1);
      10. //todo
      11. return 0;
      12. }
      13. DWORD WINAPI WorkThread2(LPVOID lp)
      14. {
      15. printf("Wait For Thread1 Leavern");
      16. WaitForSingleObject(hMutex, INFINITE);
      17. printf("TID -> %d rn", GetCurrentThreadId());
      18. ReleaseMutex(hMutex);
      19. return 0;
      20. }
      21. int main()
      22. {
      23. hMutex = CreateMutex(NULL, FALSE, NULL);
      24. HANDLE hThread1 = CreateThread(NULL, 0, WorkThread1, NULL, 0, NULL);
      25. Sleep(1000);
      26. HANDLE hThread2 = CreateThread(NULL, 0, WorkThread2, NULL, 0, NULL);
      27. WaitForSingleObject(hThread2, INFINITE);
      28. CloseHandle(hMutex);
      29. CloseHandle(hThread1);
      30. CloseHandle(hThread2);
      31. return 0;
      32. }

Семафор

  • Семафор — это объект синхронизации, используемый для управления доступом к общим ресурсам несколькими потоками. Это счетчик, который отображает количество доступных ресурсов. Когда значение семафора больше 0, это указывает на то, что ресурсы доступны; когда значение равно 0, это указывает на отсутствие доступных ресурсов.

    • ждать : пытается уменьшить значение семафора. Если значение семафора больше 0, уменьшите его на 1 и продолжите выполнение. Если значение семафора равно 0, поток блокируется до тех пор, пока значение семафора не станет больше 0.

    • освобожден : Увеличение значения семафора. Если есть другие потоки, заблокированные в ожидании этого семафора, один из них будет разбужен.

  • Создать семафор

    • В системах Windows используйте CreateSemaphore илиCreateSemaphoreEx Функция создает семафор.

  • Подождите (Wait) и отпустите (Release) семафор

    • Ожидание семафора обычно выполняется с помощью WaitForSingleObject илиWaitForMultipleObjects функция.

    • Освободить использование семафора ReleaseSemaphore функция.

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

Событие

  • В программировании Windows события — это механизм синхронизации, используемый для отправки сигналов между несколькими потоками.Объект события может бытьручной сбросилиавтоматический сброс

    • Событие ручного сброса: когда событие установлено (сигнализировано), оно останется в этом состоянии до тех пор, пока не будет явно сброшено. Это означает, что несколько потоков, ожидающих события, могут быть пробуждены до того, как событие будет сброшено.

    • Событие автоматического сброса: когда событие получено (сигнализировано) ожидающим потоком, система автоматически сбрасывает состояние события на несигнализированное (несигнализированное). Это означает, что одновременно может быть пробуждён только один поток.

  • Создать событие

    • Использование функций Windows APICreateEventОбъект события может быть создан

    • lpEventAttributes: Указатель на атрибут безопасности, если установлено значениеNULL, используется безопасность по умолчанию.

    • bManualReset: еслиTRUE, то создается событие ручного сброса, в противном случае создается событие автоматического сброса.

    • bInitialState: еслиTRUE, то начальное состояние является состоянием сигнала, если;FALSE, это несигнальное состояние.

    • lpName: Название события.

  • Чтобы установить событие (установить состояние события в состояние сигнала), используйтеSetEventфункция

  • Чтобы сбросить событие (установить состояние события в несигнальное состояние), используйтеResetEventфункция

  • Подождите, пока событие дождется, пока объект события перейдет в состояние сигнала.WaitForSingleObjectфункция

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