Какие примитивы синхронизации вы знаете?

А, ну это ж классика, ёпта! Сидишь такой, пишешь свой код, а потом бац — и у тебя потоки начинают драться за данные, как голодные пёсели за последнюю кость. Терпения ноль, ебать! Всё ломается, значения не те, гонки данных — просто пиздец. И вот тут на сцену выходят эти самые примитивы синхронизации, без них нихуя не работает.

1. Мьютексы (Mutex) Это как самый простой и тупой замок на дверь в сортир. Зашёл один поток — закрылся, сделал свои делишки, вышел — открыл. Пока он там, все остальные ждут снаружи и тупо ссут кипятком. Базовый инструмент, чтоб не лезли все в одну кучу.

// Пример на C++
std::mutex mtx;
mtx.lock(); // Закрылся в сортире. "Занято!"
// Критическая секция — доступ к общему ресурсу
shared_variable++;
mtx.unlock(); // Вышел, можно следующему.

Главное — не забудь его открыть, а то все зависнут навечно, и будет тебе хиросима в отдельно взятой программе.

2. Семафоры (Semaphore) А это уже как платная парковка с ограниченным числом мест. Допустим, у тебя три слота в пуле соединений. Семафор на три — первые три потока заезжают, работают. Четвёртый приезжает — а ему уже: "Свободных мест нет, братан, жди у шлагбаума". Кто-то уехал — освободил слот — можно следующему. Удобная штука, когда ресурсов несколько, но не бесконечно.

3. Условные переменные (Condition Variable) Вот это, блядь, хитрая жопа! Представь, что один поток должен ждать, пока другой ему что-то приготовит. Сидеть в цикле и постоянно проверять флаг — это пиздопроебибна по ресурсам. Условная переменная — это как умный звонок. Поток говорит: "Я буду спать, но разбуди меня, когда data_ready станет true". И он реально засыпает, не жрёт процессор. А другой поток, когда всё готово, будит его пинком: "Эй, вставай, работа есть!".

std::condition_variable cv;
std::mutex mtx;
bool data_ready = false;

// Поток-потребитель
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, []{ return data_ready; }); // Спит до побудки

Красота, ебать копать!

4. Атомарные операции и типы Это магия, чувак. Когда тебе нужно просто увеличить счётчик на единичку, зачем городить мьютекс со всеми его накладками? Берёшь std::atomic — и операция становится неделимой. Как будто её сделали за один такт процессора. Никто не сможет влезть посередине и всё испортить.

std::atomic<int> counter(0);
counter.fetch_add(1, std::memory_order_relaxed); // Чик — и готово. Быстро и без блокировок.

Но тут, конечно, свои подводные камни с порядками памяти, это отдельная песня.

5. Спинлоки (Spinlock) А это для самых отчаянных перфекционистов. Поток не засыпает, ожидая разблокировки, а тупо крутится в бесконечном цикле и спрашивает: "Можно уже? А сейчас? А щас?". Звучит как бред, но если твоя критическая секция выполняется быстрее, чем переключение контекста потоков ОС, то это может быть овердохуища эффективно. Хотя процессор при этом будет гудеть, как улей.

Так какой же выбрать, ёпта?

• Мьютекс — твой верный пёс для защиты любой общей хуйни. Надёжно, просто, иногда медленно.
• Условная переменная — когда нужно не просто защитить, а скоординировать: "Жди сигнала".
• Атомарные операции — для мелких быстрых действий, где блокировки — это перебор. Счётчики, флаги.
• Семафор — когда у тебя есть ограниченный пул чего-либо (потоков, соединений, принтеров).
• Спинлок — только если ты уверен, что секция короче, чем поход потока в сон и обратно. Иначе просто сожжёшь процессор впустую.

В общем, инструментов дохуя. Главное — понять задачу, а не херачить везде mutex.lock(). Иначе получишь программу, которая работает медленнее, чем одноногий хомяк в колесе.