Профиль goroutineleak в Go 1.27: как ловить зависшие горутины прямо в продакшенеСтатья · дайджест за 19 ноября
Профиль goroutineleak в Go 1.27: как ловить зависшие горутины прямо в продакшене
Статья5 разделов≈ 9 мин

Профиль goroutineleak в Go 1.27: как ловить зависшие горутины прямо в продакшене

Сервис на Go крутится неделю, графики зелёные — и вдруг оперативка начинает тихо ползти вверх. Сборщик мусора всё чаще упирается в GOMEMLIMIT, процессор греется, а в обычном /debug/pprof/goroutine висят три тысячи горутин. Поди угадай, кто просто ждёт ответа под нагрузкой, а кто завис навечно.

В Go 1.27 эту задачу решили на уровне рантайма. Встроенный профиль goroutineleak, который в Go 1.26 ещё прятался за флагом GOEXPERIMENT=goroutineleakprofile, вышел из эксперимента и работает по умолчанию. Влад Сайок разобрал его в The Go Blog: детектор опирается на сборщик мусора и почти без ложных срабатываний показывает ровно те строки, где горутины застряли навсегда.

Почему тесты и обычный pprof пропускают тихие утечки

Горутина — лёгкий поток выполнения под управлением рантайма Go. Запускать их пачками дёшево, но если горутина засыпает на канале или мьютексе, а разбудить её уже некому, случается утечка. Зависшая горутина не исчезает: она держит свой стек и все объекты, на которые смотрят её переменные. Сборщик мусора на каждом цикле снова обходит этот мёртвый граф ссылок и впустую жжёт CPU.

До Go 1.27 такие баги ловили в основном в тестах. Библиотека uber-go/goleak проверяет после юнит-теста, не остались ли лишние горутины. Пакет testing/synctest из Go 1.25 позволяет жёстко задавать порядок конкурентных событий и стабильно воспроизводить гонки. Но оба инструмента живут в тестах, а в продакшене трафик и таймауты складываются в сценарии, которых в тестах не было.

Обычный /debug/pprof/goroutine в живом сервисе тоже подводит: он сваливает в кучу всех заблокированных, не отличая вечный клинч от нормального ожидания. Медленная утечка по одной-две горутины в час легко прячется в таком шуме годами.

Ловим зависших воркеров через /debug/pprof/goroutineleak

Менять код сервиса ради нового профиля не нужно. Тип goroutineleak встроен в runtime/pprof, а если в проекте уже подключён net/http/pprof, эндпоинт /debug/pprof/goroutineleak появляется автоматически.

Проверим на классической ошибке из блога Go (похожие баги находили в продакшене Uber). Функция processWorkItems запускает воркеры и собирает ответы из небуферизованного канала make(chan result), где отправка блокируется до чтения. При первой ошибке функция сразу выходит:

package main

import (
    "errors"
    "log"
    "net/http"
    _ "net/http/pprof"
)

type workItem int
type workResult int
type result struct {
    res workResult
    err error
}

func processWorkItem(w workItem) (workResult, error) {
    if w <= 0 {
        return 0, errors.New("invalid work item")
    }
    return workResult(w * 2), nil
}

func processWorkItems(ws []workItem) ([]workResult, error) {
    // Без буфера: при раннем return воркеры зависнут на отправке
    ch := make(chan result)
    for _, w := range ws {
        go func() {
            res, err := processWorkItem(w)
            ch <- result{res, err}
        }()
    }
    var out []workResult
    for range len(ws) {
        r := <-ch
        if r.err != nil {
            return nil, r.err
        }
        out = append(out, r.res)
    }
    return out, nil
}

func handleWork(w http.ResponseWriter, _ *http.Request) {
    items := []workItem{1, 2, 3, 4, 0, 6, 7, 8, 9, 10}
    if _, err := processWorkItems(items); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
    }
}

func main() {
    http.HandleFunc("/work", handleWork)
    log.Fatal(http.ListenAndServe("localhost:6060", nil))
}

На элементе с нулевым значением processWorkItems ловит ошибку, делает ранний return и бросает канал. Остальные воркеры доходят до ch <- result{res, err} и зависают навсегда — читать из ch больше некому. Каждый запрос на /work оставляет в памяти новую пачку «зомби».

Собираем бинарник, запускаем, отправляем запросы на /work и снимаем профиль через curl и go tool pprof:

go build -o leaky && ./leaky

# В другом терминале вызываем /work и снимаем профиль утечек
curl http://localhost:6060/work
curl http://localhost:6060/debug/pprof/goroutineleak > leak.prof
go tool pprof leak.prof

После серии таких запросов команда list processWorkItems в интерактивной консоли pprof без лишнего шума указывает прямо на проблемную строку:

Type: goroutineleak
(pprof) list processWorkItems
Total: 116
ROUTINE ======================== main.processWorkItems.func1 in .../main.go
         0        116 (flat, cum)   100% of Total
         .          .     31:   go func() {
         .          .     32:       res, err := processWorkItem(w)
         .        116     33:       ch <- result{res, err}
         .          .     34:   }()

В отчёте нет ни фоновых горутин HTTP-сервера, ни таймеров — ровно 116 застрявших отправок. Фикс укладывается в одну строку: дать каналу буфер по числу задач.

// Буфер на len(ws) позволяет воркерам записать ответ и выйти
ch := make(chan result, len(ws))

Теперь каждый воркер кладёт результат в буфер без блокировки и спокойно завершается, а сам канал позже уберёт сборщик мусора.

Три реальные ловушки из продакшена: range, мьютекс и канал

В большом коде утечки прячутся не только в ранних выходах, но и в циклах или примитивах пакета sync вроде sync.Mutex и sync.WaitGroup. Вот три живых сценария из статьи Go и открытых проектов.

Первый — незакрытый канал в for range. Цикл range ch завершается только после close(ch) и вычитывания буфера. Забыл закрыть канал — все воркеры остались ждать навсегда:

func noCloseRange(list []any, workers int) {
    ch := make(chan any)
    for i := 0; i < workers; i++ {
        go func() {
            for item := range ch {
                _ = item
            }
        }()
    }
    for _, item := range list {
        ch <- item
    }
    // Без close(ch) воркеры навсегда зависнут на range ch
    close(ch)
}

Бонусная грабля: если по ошибке передать workers == 0, то на отправке ch <- item зависнет уже сама родительская горутина. Профиль goroutineleak поймает и это.

Второй случай — реальный баг из CockroachDB. Метод в цикле берёт sync.Mutex, проверяет флаг и выходит через break, забыв отпустить замок:

type Gossip struct {
    mu     sync.Mutex
    closed bool
}

func (g *Gossip) bootstrap() {
    for {
        g.mu.Lock()
        if g.closed {
            // Без Unlock() следующий вызов зависнет на Lock()
            g.mu.Unlock()
            break
        }
        g.mu.Unlock()
    }
}

Первый вызов с closed: true уходит, оставив мьютекс запертым, а любая следующая горутина встаёт на g.mu.Lock() навечно. Разблокировать замок уже некому, и профилировщик точно покажет строку с Lock().

Третий кейс — баг Moby28462 из движка Docker. Там метод StateChanged держал c.Lock() и слал сигнал в небуферизованный s.stop <- struct{}{}, а monitor() успел уйти в default и сам ждал тот же c.Lock(). Взаимный клинч починили через закрытие канала:

// close() не блокируется, Lock() освобождается, а monitor()
// выходит по ветке case <-stop
func (s *Health) CloseMonitorChannel() {
    if s.stop != nil {
        close(s.stop)
    }
}

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

Как рантайм отличает утечку от нормального ожидания

В основе goroutineleak лежат не эвристики по времени, а строгий граф достижимости. Алгоритм вырос из исследования ASPLOS 2025 Орхусского университета, Вашингтонского университета в Сент-Луисе и Uber, а в Go его довели вместе с Майклом Кнышеком, Майклом Праттом и Пи-Джеем Мэллоем.

Главное правило — индуктивная живость (liveness): горутина жива, если она не заблокирована на примитиве синхронизации, либо хотя бы один примитив, на котором она ждёт, достижим по ссылкам из другой живой горутины. Если до канала или мьютекса не дотягивается ни одна работающая горутина, разблокировать «спящую» уже некому.

Рантайм использует конкурентный трёхцветный сборщик мусора (tri-color mark-and-sweep GC, включая Green Tea GC) и проверяет достижимость в пять шагов:

  1. В стартовые корни (mark roots) попадают глобальные переменные и только незаблокированные горутины, а не все подряд.
  2. Обычная фаза маркировки обходит ссылки от корней и помечает достижимую память.
  3. Рантайм проверяет оставшиеся заблокированные горутины: если примитив, на котором висит горутина, помечен на шаге 2 — она объявляется живой, добавляется в корни, и маркировка повторяется.
  4. Когда новых живых горутин больше нет, всем оставшимся заблокированным выставляют статус leaked.
  5. Маркировка проходит последний раз уже с «утёкшими» горутинами в корнях, чтобы GC не удалил их память. После цикла pprof снимает стеки и оставляет только leaked.

Где у детектора границы и сколько это стоит по CPU

У точности без ложных срабатываний есть свои рамки. Во-первых, профиль отслеживает только встроенные примитивы Go: отправку и чтение каналов (включая nil-каналы), блокирующий select без default (включая пустой select {}), а также sync.Mutex, sync.RWMutex, sync.WaitGroup и sync.Cond. Зависания на сетевом или файловом I/O, системных вызовах и самописных спинлоках сюда не попадут.

Во-вторых, мешает memory overreach: если ссылка на забытый канал осталась в глобальной переменной или живой горутине, GC посчитает его достижимым и промолчит, даже если туда больше никто не напишет. Лечится это узкой областью видимости примитивов.

Наконец, детектор видит только уже случившиеся утечки. По памяти цена почти нулевая, а вот по CPU в патологическом сценарии «цепочки» (daisy-chain: G0 -> P1 -> G1 -> P2 -> G2 ...) маркировка выстраивается последовательно и проверка заблокированных горутин даёт худшую сложность O(n²) на цикл GC. Но сборщик при этом работает конкурентно с сервисом, а утечка никуда не пропадает со временем — поэтому в проде достаточно снимать /debug/pprof/goroutineleak раз в четыре часа, дополняя его goleak и testing/synctest в тестах.

Хочу подробный разборГолоса помогают выбрать, что разобрать подробно. За этот материал 0 голосов.
Источники · 4