Context в Go: отмена только вниз, cancel, который не про отмену, и Value, который дорожает с глубиной

Что здесь на самом деле спрашивают

Лестница почти всегда такая:

1. «Зачем контекст?» — разминка: отмена, дедлайн, значения уровня запроса.
2. «Почему первым аргументом, а не полем структуры?» — здесь начинается содержание.
3. «Что делает cancel и почему defer cancel() пишут даже при успехе?»
4. «Чем Canceled отличается от DeadlineExceeded?» — вопрос, на котором ломается обработка таймаутов.
5. «Что класть в Value?» — и почему «всё, что удобно» неверно.
6. «Как отменить операцию, которая не принимает контекст?» — вопрос на понимание, что контекст ничего не прерывает сам.

Дальше урок идёт по этой лестнице. Спина у неё одна: контекст — это дерево сигналов, а не хранилище и не средство прерывания.

База: зачем работе знать, что запрос уже не нужен

Начнём с задачи, а не с пакета.

Клиент отправил запрос. Сервер принял его и пошёл работать: сходил в базу, полез в соседний сервис, что-то посчитал. А клиент за это время закрыл вкладку и ушёл. Ответ теперь никому не нужен — но работа по нему продолжается: запрос к базе выполняется, соединение занято, память держится. То же самое, если ответа ждать уже поздно: клиент отвалился по своему сроку ожидания, а мы всё ещё считаем.

Работа, которую никто не ждёт, — это не просто лишняя работа. Под нагрузкой она вытесняет нужную: каждая брошенная задача занимает место, которое досталось бы живому запросу.

Значит, до самого низа цепочки вызовов должна как-то доходить новость: это больше не нужно. Сама по себе ни одна функция внизу её не узнает — она не видит ни клиента, ни часов. Новость надо принести, и приносят её тем же путём, каким шёл запрос: сверху вниз по вызовам. Это и есть контекст.

Переносит он три вещи:

1. отмену — новость, что работа больше не нужна;
2. срок — момент, после которого она не нужна в любом случае;
3. значения, привязанные к запросу, — то, что относится к нему целиком и должно быть видно на всём пути.

Первые две — одна и та же новость, только приходит она по разным причинам: кто-то отменил или вышло время. Третья вещь устроена иначе и разбирается отдельно.

И главное: новость сама ничего не останавливает. Она доступна для чтения — а смотреть на неё обязана сама работа. Минимальный образец выглядит так: работа ждёт двух событий сразу — «контекст закончился» и «результат готов», — и что случится раньше, то и определит исход.

select {
case res := <-ch:
    return res, nil
case <-ctx.Done():
    return nil, ctx.Err()
}

Функция, которая так написана, отменяемая. Функция, которая просто считает в цикле и никуда не смотрит, — нет, сколько контекстов ей ни передай.

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

Механизм 1: четыре назначения, которые путают

context делает четыре разных дела, и половина путаницы в теме — оттого, что их считают одним:

Первые три работают вместе и разбираются механизмами ниже. Четвёртое устроено иначе и стоит отдельно — в разделе «Глубже»; смешивать их не стоит, потому что Value не имеет отношения ни к отмене, ни к сроку.

И общая рамка, из которой выводится всё остальное: контекст — это дерево сигналов. Не хранилище и не средство прерывания.

Дерево, и связь односторонняя

Три контекста: корень и два потомка. Нажмите «отменить A» и посмотрите, что не изменится:

Прогон bench/gocontext/internals.go печатает то же самое:

отменили A:      A=context canceled  B=nil               корень=nil
отменили корень: A=context canceled  B=context canceled  корень=context canceled

Первая строка — вся суть. Отмена потомка не трогает ни родителя, ни соседа. Вторая — обратное направление: отмена родителя доходит до всех.

Отсюда сразу два практических вывода:

• Обработчик может отменить свою подзадачу, не роняя весь запрос: сделал ctx, cancel := context.WithCancel(parent), отменил — родитель не заметил.
• Отменить чужую работу можно, только держа её контекст. Поэтому его и передают явно.

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

Механизм 2: cancel — про освобождение, а не про отмену

Самый частый вопрос на понимание: зачем defer cancel(), если операция и так завершилась успешно?

Документация отвечает прямо:

Слово «утечка» стоит понимать буквально, и замер показывает, чего именно. Десять тысяч потомков долгоживущего родителя:

И это не про горутины. Первая редакция замера считала runtime.NumGoroutine() и получила ноль прибавившихся горутин в обоих случаях: WithTimeout заводит таймер рантайма, а не горутину. Утверждение «забытый cancel течёт горутинами» замер не подтвердил.

Течёт другое: пока cancel не вызван, потомок остаётся в списке потомков родителя, и ни он сам, ни то, на что он ссылается, собрано быть не может. Родитель в реальном коде живёт долго — это контекст сервиса или соединения, — поэтому список растёт вместе с числом забытых cancel.

Отсюда формулировка, которую и хотят услышать: cancel не «отменяет результат», а вычёркивает потомка из списка. Поэтому он безопасен после успеха и поэтому его пишут через defer сразу после создания контекста.

go vet это ловит проверкой lostcancel: она требует, чтобы функция отмены, возвращённая из context.WithCancel, WithTimeout и WithDeadline, была вызвана, — иначе новый контекст остаётся живым, пока не отменят родителя.

Механизм 3: срок — это тоже отмена, но по другой причине

WithTimeout(ctx, d) — это ровно WithDeadline(ctx, time.Now().Add(d)), а дедлайн — это отмена, которую назначили заранее. На шкале видно, что общего и что разного:

Слева и справа происходит одно и то же — закрывается Done(). Отличается только Err(), и вот на этом отличии ломается обработка таймаутов.

Ещё одно свойство шкалы, которое спрашивают: дедлайн потомка не может быть позже родительского. Рантайм возьмёт меньший из двух. Поэтому цепочка WithTimeout на каждом уровне не продлевает срок, а только сокращает его, — и это ровно то поведение, которого от распространения и ждут.

Canceled и DeadlineExceeded — разные ошибки

Вопрос выглядит формальным, а ломается на нём обработка таймаутов.

Прогон подтверждает: после таймаута errors.Is(err, context.DeadlineExceeded) даёт true, а errors.Is(err, context.Canceled) — false.

Почему это важно на практике. Две ситуации требуют разного поведения:

• Клиент ушёл (Canceled) — работать дальше незачем, отвечать некому, логировать как ошибку не надо.
• Не уложились в срок (DeadlineExceeded) — это уже симптом: либо зависимость медленная, либо дедлайн занижен. Такое пишут в метрики и в алерты.

Код, проверяющий только Canceled, сваливает оба случая в один — и в графиках пропадает именно то, ради чего дедлайны и ставят.

Отдельно про Background и TODO. Оба — пустые контексты, и Done() у них равен nil (чтение из nil-канала блокируется навсегда, поэтому такой контекст никогда не «сработает»). Разница между ними чисто сигнальная: Background — корень в main и в тестах, TODO — пометка «здесь потом будет настоящий контекст». Инструменты статического анализа умеют искать TODO.

Механизм 4: контекст ничего не прерывает

Самое частое заблуждение темы, и его стоит уметь сформулировать.

Отмена контекста — это сигнал, а не прерывание. ctx.Done() закрывается, и всё. Горутина, которая его не читает, продолжит работать как ни в чём не бывало. Никакого механизма «убить операцию» в языке нет — как нет и способа убить горутину.

Отсюда правило: контекст работает только там, где его читают. Три места, где это происходит:

// 1. Явная проверка в цикле.
for _, item := range items {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
    }
    process(item)
}
 
// 2. Ожидание с отменой.
select {
case res := <-ch:
    return res, nil
case <-ctx.Done():
    return nil, ctx.Err()
}
 
// 3. Библиотека, которая принимает контекст сама.
rows, err := db.QueryContext(ctx, query)
resp, err := client.Do(req.WithContext(ctx))

Третий пункт — самый важный на практике: если библиотека не принимает контекст, отменить её вызов нечем. Обёртка вида «запустить в горутине и вернуться по таймауту» отменяет только ожидание, а сама операция продолжает работать и держать ресурсы. Это законный приём, но называть его отменой нельзя, и на собеседовании эту разницу проверяют.

Механизм 5: как это выглядит на сквозном пути запроса

Всё, что разобрано выше, стоит один раз увидеть целиком — на пути, который проходит настоящий запрос:

Три сценария на этом пути, и каждый спрашивают.

Клиент отвалился. http.Server закрывает Done() контекста запроса; сигнал доходит вниз до QueryContext, и тот прерывает запрос в базе. Ошибка у обработчика — Canceled. Отвечать некому, логировать как сбой не надо.

Не уложились в две секунды. Сработал таймер обработчика, Done() закрыт, Err() — DeadlineExceeded. Это симптом: либо база медленная, либо срок занижен. Такое пишут в метрики.

Обработчик закончил раньше срока. defer cancel() вычёркивает потомка из списка родителя. Ничего не «отменяется» — освобождается место, и именно поэтому вызов обязателен и при успехе.

И главное, что видно только на целой картинке: контекст никто не «применяет» — его передают. Работу прерывает не он, а QueryContext, который его читает. Уберите из этой цепочки одно звено, передающее ctx дальше, — и всё, что ниже, перестанет отменяться, хотя код будет выглядеть правильным.

Глубже: Value — дёшево класть, дорого доставать

Правило из документации звучит строже, чем его обычно пересказывают:

Два условия сразу: данные уровня запроса и проходящие через границы. Идентификатор трассировки, данные аутентификации, идентификатор арендатора — да. Настройки функции, зависимости, конфигурация — нет: это параметры, и они должны быть видны в сигнатуре.

И вторая половина, про цену. Класть дёшево — одно выделение. Доставать дороже, и цена растёт с глубиной, потому что Value идёт вверх по цепочке родителей:

Последняя строка — мера того, насколько это не замена полю. Практический вывод: значения из контекста достают один раз на входе в обработчик, а дальше передают явно. Читать ctx.Value в горячем цикле — это платить восемнадцать раз там, где хватило бы одного.

И тут стоит удержаться от обратного перегиба. Восемнадцать — не свойство Value, а свойство двадцати слоёв: столько же слоёв над значением надо ещё суметь набрать. Правило пишется не от кратности, а от её причины: раз поиск идёт вверх по цепочке, время чтения зависит от глубины — значит, читают на входе, где глубина известна и мала, а не в цикле, где она какая получится.

И ещё одно, про типобезопасность: ключ должен быть своим неэкспортируемым типом, а не строкой.

type ctxKey string
const userKey ctxKey = "user"

Со строковым ключом два независимых пакета могут случайно взять одно и то же имя и молча перезаписать друг друга. Со своим типом это невозможно: типы разные, даже если строки совпадают.

Как отвечать на собеседовании

Короткий ответ: контекст переносит по дереву вызовов отмену, срок и значения, привязанные к запросу — чтобы работу, которая больше никому не нужна, можно было остановить, а не доводить до конца. Отмена при этом сигнал, а не прерывание: она действует только там, где Done() читают. И связь в дереве односторонняя — вниз отмена идёт, вверх и вбок нет.

Этого достаточно, чтобы ответить верно. Дальше — то, что добавляют, если собеседник копает.

Если интервьюер копает глубже

На «зачем контекст» отвечайте тремя словами и сразу четвёртым. «Отмена, дедлайн, значения уровня запроса — и всё это дерево с односторонней связью».

Про первый аргумент называйте причину, а не правило. «У каждого вызова свой дедлайн; поле структуры хранит один контекст на все вызовы, и параллельный запрос получит чужой».

Про cancel скажите «освобождает, а не отменяет». «Он вычёркивает потомка из списка потомков родителя; без него потомок висит там, пока жив родитель — у меня выходило 123 байта на потомка».

Про Canceled и DeadlineExceeded назовите разное поведение. «Клиент ушёл — работать незачем; не уложились в срок — это симптом, его пишут в метрики. Код, проверяющий только Canceled, сваливает их в одно».

Про отмену скажите, что это сигнал. «Контекст ничего не прерывает: горутина, которая не читает Done(), продолжит работать. Если библиотека не принимает контекст, отменить её вызов нечем».

Про Value назовите оба условия и цену. «Данные уровня запроса, проходящие через границы; ключ — свой неэкспортируемый тип. И доставать дорого: на двадцати слоях в восемнадцать раз дороже, чем на одном, поэтому достают один раз на входе».

Дальше спросят

Частые заблуждения

Практика

Две задачи. Сначала ответьте, потом сверьтесь с настоящим выводом: в обеих правильный ответ взят из прогона скрипта, а не назначен.

<-child.Done()
fmt.Println(errors.Is(child.Err(), context.Canceled))

_, cancelC2 := context.WithCancel(p2)
cancelC2()
fmt.Println(p2.Err() == nil)

<-tctx.Done()
fmt.Println(errors.Is(tctx.Err(), context.DeadlineExceeded))
fmt.Println(errors.Is(tctx.Err(), context.Canceled))

fmt.Println(withUser.Value(userKey))
fmt.Println(base.Value(userKey))

true
true
true
false
roman
<nil>

true
false
true
true
roman
roman

true
true
true
true
roman
<nil>

false
true
true
false
roman
<nil>

Проверка знаний