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

Има няколко основни механизма за синхронизиране на нишки в C++:

Мютекси (Mutexes): Осигуряват взаимно изключване. Само една нишка може да притежава мютекса в даден момент. Използват се за защита на общи ресурси от едновременен достъп.

#include <mutex>

std::mutex myMutex;

void criticalSection() {
    std::lock_guard<std::mutex> lock(myMutex); // Взимане на мютекса
    // Работа с общ ресурс
} // Мютексът се освобождава автоматично при изход от обхвата

Семафори: Управляват достъпа до ограничен брой ресурси. Семафорът има брояч, който показва наличните ресурси. Нишките намаляват (за получаване на ресурс) и увеличават (за освобождаване).

#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); // Увеличаване на брояча
}

Условни променливи: Позволяват на нишките да чакат определено условие. Обикновено се използват заедно с мютекси. Нишката, която чака условие, освобождава мютекса и блокира, докато другата не я уведоми за изпълнението му.

#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;
}

Атомарни променливи: Позволяват изпълнението на прости операции (четене, писане, модификация) атомарно, без необходимост от използване на мютекси за тези операции.
```
#include <atomic>

std::atomic_int atomicCounter(0);

void incrementCounter() {
    atomicCounter++; // Атомично увеличение
}
```

Бариери: Синхронизират няколко нишки така, че никоя не може да продължи изпълнението, докато всички не достигнат бариерата.

#include <barrier> // C++20

std::barrier myBarrier(3); // Бариера за 3 нишки

void workerThread() {
    // Изпълнение на част от работата
    myBarrier.arrive_and_wait(); // Изчакване на всички нишки на бариерата
    // Изпълнение на следващата част от работата
}

Изборът на конкретен механизъм зависи от характера на взаимодействието между нишките:

Мютекси: Най-често използваният начин за защита на общи данни.
Семафори: Управление на достъпа до ограничени ресурси.
Условни променливи: Изчакване на нишката за настъпване на определено събитие или състояние.
Атомарни променливи: Ефективно изпълнение на прости, атомарни операции.
Бариери: Синхронизиране на нишки за съвместен преход към следващия етап.

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