Какие знаешь механизмы синхронизации в стандартной библиотеке

1️⃣ Как кратко ответить

В стандартной библиотеке C++ для синхронизации потоков используются следующие механизмы: мьютексы (std::mutex, std::recursive_mutex, std::timed_mutex, std::recursive_timed_mutex), условные переменные (std::condition_variable, std::condition_variable_any), барьеры (std::barrier), семафоры (std::counting_semaphore, std::binary_semaphore), блокировки (std::lock_guard, std::unique_lock, std::shared_lock), а также атомарные операции (std::atomic).

2️⃣ Подробное объяснение темы

Синхронизация потоков в C++ необходима для безопасного доступа к общим ресурсам из нескольких потоков. Без надлежащей синхронизации могут возникать состояния гонки, что приводит к непредсказуемому поведению программы. Рассмотрим основные механизмы синхронизации, предоставляемые стандартной библиотекой C++.

Мьютексы

Мьютексы (mutexes) — это объекты, которые используются для предотвращения одновременного доступа к ресурсу несколькими потоками. Они обеспечивают эксклюзивный доступ к ресурсу.

• std::mutex: базовый мьютекс, который блокируется и разблокируется.
• std::recursive_mutex: позволяет одному и тому же потоку захватывать мьютекс несколько раз без блокировки.
• std::timed_mutex: расширяет std::mutex, добавляя возможность блокировки с тайм-аутом.
• std::recursive_timed_mutex: сочетает возможности std::recursive_mutex и std::timed_mutex.

Пример использования std::mutex:

#include <iostream>
#include <thread>
#include <mutex>
​
std::mutex mtx; // Создание мьютекса
​
void print_thread_id(int id) {
    mtx.lock(); // Блокировка мьютекса
    std::cout << "Thread ID: " << id << std::endl;
    mtx.unlock(); // Разблокировка мьютекса
}
​
int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);
​
    t1.join();
    t2.join();
​
    return 0;
}

Условные переменные

Условные переменные позволяют потокам ожидать определенного условия, прежде чем продолжить выполнение. Они используются в сочетании с мьютексами.

• std::condition_variable: используется с std::unique_lock.
• std::condition_variable_any: может использоваться с любым типом блокировки.

Пример использования std::condition_variable:

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
​
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
​
void print_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; }); // Ожидание сигнала
    std::cout << "Thread ID: " << id << std::endl;
}
​
void set_ready() {
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_all(); // Уведомление всех ожидающих потоков
}
​
int main() {
    std::thread t1(print_id, 1);
    std::thread t2(print_id, 2);
​
    std::this_thread::sleep_for(std::chrono::seconds(1));
    set_ready();
​
    t1.join();
    t2.join();
​
    return 0;
}

Барьеры

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

• std::barrier: позволяет синхронизировать выполнение группы потоков.

Пример использования std::barrier:

#include <iostream>
#include <thread>
#include <barrier>
​
std::barrier sync_point(3); // Барьер для трех потоков
​
void task(int id) {
    std::cout << "Thread " << id << " reached the barrier." << std::endl;
    sync_point.arrive_and_wait(); // Ожидание всех потоков
    std::cout << "Thread " << id << " passed the barrier." << std::endl;
}
​
int main() {
    std::thread t1(task, 1);
    std::thread t2(task, 2);
    std::thread t3(task, 3);
​
    t1.join();
    t2.join();
    t3.join();
​
    return 0;
}

Семафоры

Семафоры управляют доступом к ресурсу, позволяя ограниченному числу потоков использовать его одновременно.

• std::counting_semaphore: семафор с возможностью подсчета.
• std::binary_semaphore: двоичный семафор, который может быть в состоянии "захвачен" или "свободен".

Пример использования std::counting_semaphore:

#include <iostream>
#include <thread>
#include <semaphore>
​
std::counting_semaphore<2> sem(2); // Семафор, позволяющий двум потокам одновременно
​
void task(int id) {
    sem.acquire(); // Захват семафора
    std::cout << "Thread " << id << " is in the critical section." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    sem.release(); // Освобождение семафора
}
​
int main() {
    std::thread t1(task, 1);
    std::thread t2(task, 2);
    std::thread t3(task, 3);
​
    t1.join();
    t2.join();
    t3.join();
​
    return 0;
}

Блокировки

Блокировки обеспечивают более гибкое управление мьютексами.

• std::lock_guard: простой RAII-объект для автоматической блокировки и разблокировки мьютекса.
• std::unique_lock: более гибкий, чем std::lock_guard, позволяет вручную управлять блокировкой.
• std::shared_lock: используется для совместного доступа к ресурсу.

Пример использования std::lock_guard:

#include <iostream>
#include <thread>
#include <mutex>
​
std::mutex mtx;
​
void print_thread_id(int id) {
    std::lock_guard<std::mutex> lock(mtx); // Автоматическая блокировка и разблокировка
    std::cout << "Thread ID: " << id << std::endl;
}
​
int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);
​
    t1.join();
    t2.join();
​
    return 0;
}

Атомарные операции

Атомарные операции позволяют выполнять операции над переменными без использования мьютексов, обеспечивая при этом безопасность потоков.

• std::atomic: шаблонный класс для атомарных операций.

Пример использования std::atomic:

#include <iostream>
#include <thread>
#include <atomic>
​
std::atomic<int> counter(0);
​
void increment() {
    for (int i = 0; i < 1000; ++i) {
        ++counter; // Атомарное увеличение
    }
}
​
int main() {
    std::thread t1(increment);
    std::thread t2(increment);
​
    t1.join();
    t2.join();
​
    std::cout << "Counter: " << counter << std::endl;
    return 0;
}

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