DNK_C_C++_Go_Rust

#221_Cpp_MTH_PkS_TP

Как избежать состояния гонки?

Чтобы избежать состояния гонки (race condition) в многопоточной программе, следует применять различные методы синхронизации и координации потоков.

Мьютекс (Mutex от английского "mutual exclusion" — взаимное исключение) — позволяет ограничить доступ к общему ресурсу так, чтобы только один поток мог работать с ним в конкретный момент времени.
Это предотвращает состояние гонки, связанное с изменением общих данных.

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

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
int shared_counter = 0;

void incrementCounter() {
/* Захватываем мьютекс перед работой с общей переменной */
std::lock_guard<std::mutex> lock(mtx);
shared_counter++;
}

int main() {
std::thread t1(incrementCounter);
std::thread t2(incrementCounter);

t1.join();
t2.join();

std::cout << "Shared counter: " << shared_counter << std::endl;
return 0;
}

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

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

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> shared_counter(0);

void incrementCounter() {
shared_counter++;
}

int main() {
std::thread t1(incrementCounter);
std::thread t2(incrementCounter);

t1.join();
t2.join();

std::cout << "Shared counter: " << shared_counter << std::endl;
return 0;
}

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

Пример на C++ с использованием std::counting_semaphore (C++20):

#include <iostream>
#include <thread>
#include <semaphore>

/* Семафор с начальным значением 1 */
std::counting_semaphore<1> sem(1);
int shared_counter = 0;

void incrementCounter() {
// Ожидание разрешения
sem.acquire();
shared_counter++;
// Освобождение разрешения
sem.release();
}

int main() {
std::thread t1(incrementCounter);
std::thread t2(incrementCounter);

t1.join();
t2.join();

std::cout << "Shared counter: " << shared_counter << std::endl;
return 0;
}

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

Пример на C++ с использованием std::barrier (C++20):

#include <iostream>
#include <thread>
#include <barrier>

std::barrier barrier(2);
int shared_counter = 0;

void incrementCounter() {
shared_counter++;
/* Все потоки дожидаются друг друга */
barrier.arrive_and_wait();
if (std::this_thread::get_id() == std::thread::id()) {
std::cout << "Shared counter: " << shared_counter << std::endl;
}
}

int main() {
std::thread t1(incrementCounter);
std::thread t2(incrementCounter);

t1.join();
t2.join();

return 0;
}

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

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

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;
int shared_counter = 0;

void waitForWork() {
std::unique_lock<std::mutex> lck(mtx);
cv.wait(lck, []{ return ready; });
shared_counter++;
}

void signalWork() {
{
std::lock_guard<std::mutex> lck(mtx);
ready = true;
}
cv.notify_all();
}

int main() {
std::thread t1(waitForWork);
std::thread t2(signalWork);

t1.join();
t2.join();
std::cout << "Shared counter: " << shared_counter << std::endl;
return 0;
}

3 viewsПавел "barracol", edited 17:11