Что значит Deadlock при работе с горутиной?

Что такое Deadlock (взаимная блокировка) при работе с горутинами?

Deadlock (взаимная блокировка) — это состояние параллельной программы, при котором две или более горутины бесконечно ожидают друг друга, не имея возможности продолжить выполнение. Каждая заблокированная горутина удерживает ресурс, необходимый другой, создавая циклическую зависимость. Это классическая проблема многопоточного программирования, которая в контексте Go проявляется при неправильном использовании каналов (channels), мьютексов (sync.Mutex) или других примитивов синхронизации.

Основные причины Deadlock в Go

1. Взаимная блокировка при обмене данными через каналы без буферизации

Наиболее частая причина. Небуферизованные каналы требуют, чтобы операция отправки (ch <- value) и операция приёма (<-ch) были готовы одновременно. Если горутина отправляет данные в канал, но нет другой горутины, готовой их принять (или наоборот), выполнение блокируется навсегда.

package main

func main() {
    ch := make(chan int) // Небуферизованный канал
    ch <- 42             // Основная горутина блокируется здесь навсегда
    // Нет другой горутины, которая бы приняла значение
    <-ch // Эта строка никогда не выполнится
}

2. Циклическая зависимость при использовании мьютексов

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

package main

import (
    "sync"
    "time"
)

var mutexA, mutexB sync.Mutex

func goroutine1() {
    mutexA.Lock()
    time.Sleep(10 * time.Millisecond)
    mutexB.Lock() // Блокировка: mutexB уже захвачен goroutine2
    // Критическая секция
    mutexB.Unlock()
    mutexA.Unlock()
}

func goroutine2() {
    mutexB.Lock()
    time.Sleep(10 * time.Millisecond)
    mutexA.Lock() // Блокировка: mutexA уже захвачен goroutine1
    // Критическая секция
    mutexA.Unlock()
    mutexB.Unlock()
}

func main() {
    go goroutine1()
    go goroutine2()
    time.Sleep(1 * time.Second) // Обе горутины заблокированы навсегда
}

3. Ожидание завершения горутин, которые никогда не завершатся

Например, основная горутина ожидает через WaitGroup, но одна из рабочих горутин заблокирована.

package main

import "sync"

func worker(wg *sync.WaitGroup, ch chan int) {
    defer wg.Done()
    <-ch // Блокировка: никто не отправит данные в этот канал
}

func main() {
    var wg sync.WaitGroup
    ch := make(chan int)
    
    wg.Add(1)
    go worker(&wg, ch)
    
    wg.Wait() // Основная горутина блокируется навсегда
}

4. Забытая операция отправки или приёма в select

Использование select с каналами без default может привести к блокировке, если ни один из каналов не готов.

package main

import "time"

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    
    go func() {
        time.Sleep(2 * time.Second)
        ch1 <- 1
    }()
    
    select {
    case <-ch1: // ch1 станет готовым через 2 секунды
        println("ch1 ready")
    case <-ch2: // ch2 никогда не станет готовым
        println("ch2 ready") // Эта ветка никогда не выполнится
    // Без default select будет ждать готовности ch1 или ch2
    }
}

Как избежать Deadlock в Go: практические рекомендации

1. Всегда проектируйте порядок захвата ресурсов

• Используйте строгую иерархию блокировок: захватывайте мьютексы всегда в одном и том же порядке.
• При работе с несколькими ресурсами применяйте стратегию "всё или ничего" (например, через sync.Mutex.TryLock в Go 1.18+).

2. Правильно используйте каналы

• Для простых случаев используйте буферизованные каналы, но осторожно — они маскируют проблемы синхронизации.
• Всегда закрывайте каналы, когда больше не нужно отправлять данные, чтобы принимающие горутины могли выйти из циклов for v := range ch.
• Используйте context.WithCancel или context.WithTimeout для отмены операций.

3. Используйте инструменты анализа

• Запускайте программу с -race флагом для детекции гонок данных: go run -race main.go.
• Используйте статические анализаторы: go vet, golangci-lint.
• В сложных системах применяйте формальную верификацию через библиотеки вроде github.com/loov/gorace.

4. Практикуйте defensive programming

• Всегда используйте select с таймаутами или веткой default для неблокирующих операций.
• Разделяйте ответственность: одна горутина — отправляет, другая — принимает, избегайте двунаправленных каналов.
• Используйте шаблон "worker pool" для ограничения количества параллельных операций.

// Пример с таймаутом
select {
case result := <-ch:
    println("Получен результат:", result)
case <-time.After(1 * time.Second):
    println("Таймаут операции")
}

Как диагностировать Deadlock в Go

1. Программа "зависает" без завершения и без паники.
2. Высокий рост использования памяти может быть косвенным признаком (горутины накапливаются).
3. Используйте pprof для анализа горутин:

   import _ "net/http/pprof"
   go http.ListenAndServe("localhost:6060", nil)
   

   Затем откройте http://localhost:6060/debug/pprof/goroutine?debug=2.
4. Визуализируйте выполнение с помощью trace:

   import "runtime/trace"
   trace.Start(w)
   defer trace.Stop()
   

Deadlock — не ошибка времени выполнения (panic), а логическая ошибка проектирования. Компилятор Go не может её обнаружить на этапе компиляции, но рантайм Go детектирует некоторые deadlock'и в основном потоке (main goroutine) и завершает программу с сообщением fatal error: all goroutines are asleep - deadlock!. Однако для фоновых горутин такой детекции нет — они просто "засыпают" навсегда.

Главный принцип профилактики: всегда предусматривайте условия выхода из горутин, используйте таймауты и чётко определяйте жизненные циклы параллельных операций.