Причина взаимной блокировки (deadlock)
- Обычная причина — инверсия порядка захвата нескольких мьютексов: поток A берет мьютекс a, потом b; поток B берет b, потом a. Если оба успевают взять первый мьютекс — получается взаимная блокировка.
- Другие причины: повторная блокировка невосстанавливаемого (non‑recursive) мьютекса тем же потоком, удержание мьютекса при ожидании операции ввода/вывода или другого блокирующего действия.
Способы устранения (кратко)
1) Переструктурирование блокировок (рекомендуется)
- Строго установить глобальный порядок захвата мьютексов и всегда его соблюдать (например: сначала a, потом b).
- Минимизировать время удержания мьютекса; не держать мьютекс во время блокирующих операций.
2) Применение таймаутов / попыток
- Использовать pthread_mutex_trylock с повторными попытками и экспоненциальным бэк‑офом, либо pthread_mutex_timedlock (если поддерживается), чтобы обнаружить и выйти из возможного тупика.
3) Детектирование и откат (в стиле транзакций)
- При неудаче (trylock неудачен) откатить уже взятые мьютексы, подождать/перестроиться и повторить. Можно логировать зависимые блокировки и применять алгоритм обнаружения цикла (реже в простых приложениях).
4) Альтернативы
- Использовать один объединённый мьютекс вместо нескольких, используемые lock‑free структуры или условные переменные, рефакторинг для уменьшения количества общих ресурсов.
- Если нужно повторное захватывание тем же потоком — использовать PTHREAD_MUTEX_RECURSIVE (только если действительно требуется).
Примеры
Исходная проблемная схема (типичный deadlock):
```c
// Поток 1
pthread_mutex_lock(&a);
pthread_mutex_lock(&b); // может блокироваться
// Поток 2
pthread_mutex_lock(&b);
pthread_mutex_lock(&a); // deadlock возможен
```
Исправление способом строгого порядка (все потоки одинаково: сначала a, потом b):
```c
// Во всех потоках — один и тот же порядок
pthread_mutex_lock(&a);
pthread_mutex_lock(&b);
/* работа с ресурсами */
pthread_mutex_unlock(&b);
pthread_mutex_unlock(&a);
```
Пример с pthread_mutex_trylock + откат (детектирование и повтор):
```c
void lock_two_with_retry(pthread_mutex_t *m1, pthread_mutex_t *m2) {
for (;;) {
if (pthread_mutex_trylock(m1) == 0) {
if (pthread_mutex_trylock(m2) == 0) {
// оба захвачены
return;
} else {
// не удалось взять второй — откатываем первый и ждем
pthread_mutex_unlock(m1);
}
}
// небольшая пауза перед повторной попыткой
sched_yield(); // или nanosleep/экспоненциальный бэк-оф
}
}
```
Пример с pthread_mutex_timedlock (таймаут):
```c
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 1; // ждать до одной секунды
if (pthread_mutex_timedlock(&a, &ts) == 0) {
// захватили a
if (pthread_mutex_timedlock(&b, &ts) == 0) {
// оба захвачены
} else {
pthread_mutex_unlock(&a);
// обработать таймаут / повторить
}
} else {
// обработать таймаут при захвате a
}
```
Краткая рекомендация
- Самый простой и надёжный способ — ввести и соблюдать глобальный порядок захвата мьютексов и минимизировать время удержания блокировок. Для более гибкого поведения — trylock/timedlock с откатом.