Как можно синхронизировать взаимодействие между потоками?

Существует несколько основных механизмов синхронизации потоков в C++:

• Мьютексы (Mutexes): Обеспечивают взаимное исключение. Только один поток может владеть мьютексом в любой момент времени. Используются для защиты общих ресурсов от одновременного доступа.

  #include <mutex>
  
  std::mutex myMutex;
  
  void criticalSection() {
      std::lock_guard<std::mutex> lock(myMutex); // Захват мьютекса
      // Работа с общим ресурсом
  } // Мьютекс автоматически освобождается при выходе из области видимости
  

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

  #include <semaphore.h> // Обычно используется в POSIX-системах
  
  sem_t mySemaphore;
  
  void initSemaphore(int count) {
      sem_init(&mySemaphore, 0, count); // Инициализация семафора со счетчиком count
  }
  
  void acquireResource() {
      sem_wait(&mySemaphore); // Уменьшение счетчика, блокировка при 0
      // Использование ресурса
  }
  
  void releaseResource() {
      sem_post(&mySemaphore); // Увеличение счетчика
  }
  

• Условные переменные (Condition Variables): Позволяют потокам ждать определенного условия. Обычно используются вместе с мьютексами. Поток, ожидающий условия, освобождает мьютекс и блокируется до тех пор, пока другой поток не уведомит его о выполнении условия.

  #include <condition_variable>
  #include <mutex>
  #include <queue>
  
  std::condition_variable myCondition;
  std::mutex myMutex;
  std::queue<int> myQueue;
  
  void producer(int value) {
      std::lock_guard<std::mutex> lock(myMutex);
      myQueue.push(value);
      myCondition.notify_one(); // Уведомление одного ждущего потока
  }
  
  int consumer() {
      std::unique_lock<std::mutex> lock(myMutex);
      myCondition.wait(lock, [&]{ return !myQueue.empty(); }); // Ожидание условия
      int value = myQueue.front();
      myQueue.pop();
      return value;
  }
  

• Флаги атомарной переменной (Atomic Variables): Позволяют выполнять простые операции (чтение, запись, модификация) над переменными атомарно, без необходимости использования мьютексов для этих конкретных операций.

  #include <atomic>
  
  std::atomic_int atomicCounter(0);
  
  void incrementCounter() {
      atomicCounter++; // Атомарное увеличение
  }
  

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

  #include <barrier> // C++20
  
  std::barrier myBarrier(3); // Барьер для 3 потоков
  
  void workerThread() {
      // Выполнение части работы
      myBarrier.arrive_and_wait(); // Ожидание всех потоков у барьера
      // Выполнение следующей части работы
  }
  

Выбор конкретного механизма зависит от характера взаимодействия между потоками:

• Мьютексы: Самый распространенный способ защиты общих данных.
• Семафоры: Управление доступом к ограниченному количеству ресурсов.
• Условные переменные: Ожидание потоком наступления определенного события или состояния.
• Атомарные переменные: Эффективное выполнение простых, атомарных операций.
• Барьеры: Синхронизация потоков для совместного перехода к следующему этапу.