Коротко о сути и решениях.
Что такое состояние гонки (race)?
- Когда два и более потока одновременно обращаются к общей изменяемой памяти и хотя бы один из них выполняет запись, порядок межлётных операций не определён — возможны «потерянные обновления», неконсистентные проверки («check‑then‑act»), use‑after‑free, непредсказуемые данные. Примеры: инкремент счётчика без синхронизации (lost update), проверка `if (ptr==NULL) init()` в двух потоках (двойная инициализация), удаление элемента контейнера в одном потоке при итерации в другом (утечка/крэш).
Основные методы синхронизации
- Мьютексы (mutex)
- Гарантируют взаимное исключение в критической секции.
- Простая и безопасная модель, но имеет накладные и риск дедлока при неправильном порядке захвата.
- API: `pthread_mutex_lock`, `pthread_mutex_unlock`.
- Пример: защита инкремента счётчика.
- Условные переменные (condition variables)
- Используются вместе с мьютексом для ожидания/оповещения о событиях (producer/consumer).
- Нужна проверка условия в цикле `while (!cond) pthread_cond_wait(&cv,&m);`.
- API: `pthread_cond_wait`, `pthread_cond_signal`, `pthread_cond_broadcast`.
- Атомарные операции (atomics)
- Для простых RMW (read‑modify‑write) операций — атомарный инкремент, CAS (compare‑and‑swap).
- В C11: `_Atomic` и `atomic_fetch_add`, `atomic_compare_exchange_*`. В GCC/Clang есть `__atomic`/`__sync` builtins.
- Могут давать lock‑free/wait‑free поведение и меньшую задержку в высоконагруженных сценариях.
- pthread_once / одна инициализация
- Безопасный способ выполнить инициализацию один раз: `pthread_once`.
- Reader‑writer locks и RCU‑паттерны
- `pthread_rwlock_t` для оптимизации чтения‑часто/запись‑редко.
- RCU/immutable‑publishing: читатели без блокировок читают неизменяемую структуру, писатели подготавливают новую и атомически подменяют указатель.
- Замечание: `volatile` не решает синхронизацию и порядок — нужна именно синхронизация/барьеры памяти.
Типичные ошибки и риски
- Дедлок — несогласованный порядок захвата нескольких мьютексов.
- Возврат/освобождение ресурса пока другой поток всё ещё читает (use‑after‑free).
- Неправильное использование условной переменной без цикла проверки условия.
- Неправильные порядок/стороны памяти при lock‑free — требуется понимание acquire/release.
Примеры эффективных шаблонов
1) Простая защита критической секции (mutex)
```c
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
void* worker(void* arg){
pthread_mutex_lock(&m);
counter++; /* защита от race */
pthread_mutex_unlock(&m);
return NULL;
}
```
2) Producer/consumer с условной переменной
```c
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
queue_t q;
void producer(...) {
pthread_mutex_lock(&m);
enqueue(&q, item);
pthread_cond_signal(&cv);
pthread_mutex_unlock(&m);
}
void consumer(...) {
pthread_mutex_lock(&m);
while (queue_empty(&q)) {
pthread_cond_wait(&cv, &m);
}
item = dequeue(&q);
pthread_mutex_unlock(&m);
}
```
3) Атомарный счётчик (C11)
```c
_Atomic int counter = 0;
void* worker(void* arg){
atomic_fetch_add(&counter, 1); /* lock‑free инкремент */
return NULL;
}
```
4) Lock‑free стек (идея через CAS)
```c
typedef struct node { struct node* next; int val; } node;
_Atomic(node*) top = NULL;
void push(node* n) {
node* old;
do {
old = atomic_load(&top);
n->next = old;
} while (!atomic_compare_exchange_weak(&top, &old, n));
}
```
(для pop нужен осторожный порядок освобождения памяти — Hazard pointers / epoch/RCU.)
5) Безопасная однократная инициализация
```c
pthread_once_t once = PTHREAD_ONCE_INIT;
void init_once(void) { /* инициализация */ }
void use() {
pthread_once(&once, init_once);
/* дальше безопасно */
}
```
Рекомендации по выбору
- Для простых случаев и умеренной нагрузки — мьютекс + condvar.
- Для высокой нагрузки и простой операции (инкремент) — атомики.
- Для инициализации — `pthread_once`.
- Для чтений‑часто/записей‑редко — rwlock или immutable‑publish (RCU).
- Избегайте вручную реализованных двойных проверок без правильных барьеров памяти; используйте atomics или pthread_once.
Коротко: предотвращайте race, гарантируя либо взаимное исключение (мьютексы), либо использование атомарных операций с нужными семантиками памяти; для сложных lock‑free структур применяйте проверенные шаблоны (CAS + безопасный порядок освобождения памяти) или готовые примитивы pthread.