# Вопросы на собеседовании по Go

297 вопросов с реальных собеседований. Здесь открытые: первые вопросы каждой подтемы с коротким ответом (первый абзац эталона) и источником. Все вопросы с ответами и AI-разбором — в тренажёре JobJump.

Страница: https://jobjump.app/questions/go

## Основы языка

### Каковы ключевые особенности и сильные стороны языка Go?

Go — компилируемый, статически типизированный язык со сборкой мусора, созданный в Google ради простоты и масштабируемой разработки.

Источник: https://go.dev/doc/faq

### Какая типизация используется в Go — статическая или динамическая, и что это означает на практике?

Go **статически и строго типизирован**: тип каждой переменной известен на этапе компиляции и не меняется в рантайме, а несоответствие типов — ошибка компиляции. Неявных преобразований между типизированными значениями нет даже между числовыми типами — нужно явное приведение (исключение — нетипизированные константы: `var f float64 = 1` допустимо). При этом есть вывод типов: в `x := 42` компилятор сам определяет тип по правой части, но переменная всё равно остаётся статически типизированной.

Источник: https://go.dev/ref/spec#Types

### Какие числовые типы есть в Go и в чём их особенности?

Есть целые со знаком (int8/16/32/64) и без (uint8/16/32/64), а также int/uint, размер которых зависит от платформы (32 или 64 бита), и uintptr. Есть вещественные float32/float64 и комплексные complex64/128, а также псевдонимы byte (= uint8) и rune (= int32). **Числовые типы несовместимы без явного преобразования**, даже `int` и `int64`. Переполнение беззнаковых определено как арифметика по модулю 2^n; для знаковых результат тоже детерминирован (обёртка в дополнительном коде), паники нет. Граница: переполнение константного выражения — ошибка компиляции, а не обёртка.

Источник: https://go.dev/ref/spec#Numeric_types

### Чем объявление переменной через var отличается от краткого объявления через := ?

`var x int = 5` (или `var x int`) объявляет переменную на любом уровне, включая пакетный; без инициализатора переменная получает нулевое значение своего типа. Краткое объявление `x := 5` допустимо только внутри функций, тип выводится из выражения. `:=` требует, чтобы слева была хотя бы одна новая переменная; остальные, уже объявленные **в том же блоке**, получают присваивание, а не создаются заново (в другом, вложенном блоке `:=` создаст новую переменную — см. затенение).

Источник: https://go.dev/ref/spec#Short_variable_declarations

## Типы, значения и указатели

### Что такое нулевое значение (zero value) в Go и каким типам какое значение назначается по умолчанию?

Любая переменная, объявленная без инициализатора, получает нулевое значение своего типа: `0` для чисел, `false` для `bool`, `""` для строк, `nil` для указателей, срезов, мап, каналов, функций и интерфейсов.

Источник: https://go.dev/ref/spec#The_zero_value

### Как в Go передаются аргументы в функции — по значению или по ссылке?

В Go аргументы всегда передаются по значению: функция получает копию, передачи по ссылке нет.

Источник: https://go.dev/doc/faq#pass_by_value

### Что такое указатель в Go и для чего он нужен?

Указатель хранит адрес значения в памяти: `&x` берёт адрес, `*p` разыменовывает.

Источник: https://go.dev/ref/spec#Pointer_types

## Массивы и слайсы

### В чём разница между массивом и слайсом в Go?

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

Источник: https://go.dev/ref/spec#Array_types

### Как устроен слайс под капотом и из каких полей состоит его заголовок?

Слайс — заголовок из трёх полей: указатель на первый элемент базового массива, длина (`len`) и ёмкость (`cap`); сами данные лежат в отдельном массиве.

Источник: https://go.dev/blog/slices-intro

### В чём разница между длиной (len) и ёмкостью (cap) слайса и зачем нужна ёмкость?

`len` — сколько элементов сейчас доступно в слайсе, `cap` — сколько элементов слайс может занять без новой аллокации, то есть сколько места под него выделено в базовом массиве.

Источник: https://go.dev/ref/spec#Length_and_capacity

### Как работает append и по какому правилу растёт ёмкость слайса?

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

Источник: https://go.dev/blog/slices-intro

### Будут ли видны в вызывающей функции элементы, добавленные через append в слайс, переданный по значению?

**Нет**. Функция получает копию заголовка слайса (указатель, len, cap). append внутри функции обновляет её локальный len (и, возможно, указатель при переаллокации), но заголовок вызывающего не меняется — там len прежний, поэтому новые элементы он «не видит». Даже если места хватило и append записал элемент в общий базовый массив, вызывающий не увидит его без переразрезания (`s[:n+1]`), так как его len не увеличился.

Источник: https://go.dev/blog/slices-intro

### Если изменить элементы под-слайса, повлияет ли это на исходный слайс, и почему?

Да, повлияет: под-слайс `s[1:3]` не копирует данные, а ссылается на тот же базовый массив, поэтому запись через него видна в исходном слайсе, и наоборот.

Источник: https://go.dev/blog/slices-intro

## Мапы

### Как устроена мапа (хеш-таблица) в Go под капотом?

Мапа — хеш-таблица на Swiss Tables (с Go 1.24). Верхнеуровневый Map держит directory таблиц, таблица — массив групп по 8 слотов, у каждой группы 8-байтовое control-слово (слот занят, пуст или удалён плюс 7 бит хеша). Мапа до 8 элементов — одна группа без directory. Переменная-мапа указывает на этот Map, поэтому копия переменной ссылается на ту же таблицу.

Источник: https://github.com/golang/go/blob/go1.26.0/src/internal/runtime/maps/map.go

### Какова асимптотическая сложность операций с мапой в среднем и худшем случаях?

В среднем поиск, вставка и удаление — амортизированные **O(1)**: хеш сразу приводит к нужной группе, а рост таблицы размазан по операциям. Худший случай — **O(n)**: если все ключи дают одну и ту же последовательность проб и поиск вырождается в перебор.

Источник: https://github.com/golang/go/blob/go1.26.0/src/internal/runtime/maps/map.go

### Как в мапе Go разрешаются коллизии хешей?

Коллизии разрешаются открытой адресацией: при занятых слотах поиск идёт по группам квадратичным пробированием, пока не найдётся ключ или группа со свободным слотом. Внутри группы из 8 слотов 7-битные H2-метки всех слотов сверяются с хешем одной операцией по control-слову, полное сравнение ключа нужно только при совпадении метки. Удаление из полностью заполненной группы оставляет tombstone, чтобы не оборвать цепочку проб.

Источник: https://github.com/golang/go/blob/go1.26.0/src/internal/runtime/maps/map.go

### Гарантируется ли порядок обхода мапы через range и почему он такой?

**Нет**. Спецификация прямо говорит: порядок обхода мапы не определён и не гарантируется одинаковым от прохода к проходу. Более того, рантайм намеренно рандомизирует старт range (случайная точка старта), чтобы никто не полагался на порядок и код не ломался при смене реализации мапы. Если нужен детерминированный порядок — соберите ключи в слайс и отсортируйте (`slices.Sorted(maps.Keys(m))`, Go 1.23+), а затем обходите мапу по этому слайсу.

Источник: https://go.dev/ref/spec#For_range

### Какое значение имеет неинициализированная (nil) мапа и какие операции с ней допустимы, а какие вызовут панику?

Мапа, не созданная через `make` или литерал (`var m map[string]int`), равна nil. С ней можно читать (вернётся нулевое значение), брать `len` (0), обходить `range` (ноль итераций) и вызывать `delete` (no-op).

Источник: https://go.dev/ref/spec#Map_types

## Строки, руны и байты

### Как устроена строка в Go на уровне внутреннего представления?

Строка — это небольшой заголовок из двух полей: указателя на байты и длины в байтах. Сами байты лежат отдельно от заголовка, и менять их через строку нельзя: язык гарантирует неизменяемость. Байты литералов компилятор кладёт в секцию только для чтения, а строки, собранные в рантайме, обычно лежат в куче (короткую строку, которая не покидает функцию, компилятор может разместить на стеке). Строка не хранит завершающий ноль, как в C, — длина известна явно. Байты трактуются как UTF-8, но язык этого не навязывает: строка может содержать произвольные байты. Поскольку заголовок маленький, передача и присваивание строки копируют лишь два слова, а сами байты разделяются — это дёшево именно благодаря неизменяемости.

Источник: https://go.dev/blog/strings

### Что следует из того, что строка в Go неизменяема?

Раз байты строки менять нельзя, изменить байт по индексу (`s[0] = 'x'`) невозможно — это ошибка компиляции. Любое «изменение» строки на деле создаёт новую. Зато из неизменяемости следуют приятные свойства: байты строки можно читать из нескольких горутин без блокировок, потому что их никто не изменит (общую переменную строки, которую переприсваивают, это не защищает), под-строку (`s[i:j]`) можно делать без копирования — она указывает на те же байты.

Источник: https://go.dev/blog/strings

### В чём разница между типами rune и byte?

`byte` — псевдоним `uint8`, один байт данных; `rune` — псевдоним `int32`, один кодпоинт Unicode.

Источник: https://go.dev/blog/strings

## Структуры, методы и встраивание

### В чём разница между методом с получателем по значению и по указателю?

Метод с получателем по значению работает с копией: изменения полей внутри метода снаружи не видны. Метод с получателем по указателю работает с самим объектом: может его менять и не копирует структуру при вызове.

Источник: https://go.dev/ref/spec#Method_sets

### В каких случаях следует использовать получатель по указателю, а в каких по значению?

Получатель-указатель нужен, когда метод должен менять получателя, когда структура большая или когда тип содержит то, что нельзя копировать (например, `sync.Mutex`); получатель по значению подходит для небольших неизменяемых типов.

Источник: https://go.dev/wiki/CodeReviewComments#receiver-type

### Допустимо ли смешивать методы с получателями по значению и по указателю у одного типа?

Компилятор смешивание допускает, но так делать не рекомендуется: набор методов значения `T` и набор методов `*T` различаются, и это даёт неочевидные ошибки.

Источник: https://go.dev/wiki/CodeReviewComments#receiver-type

### Почему вызов метода у nil-указателя не всегда приводит к панике, а обращение к полю приводит?

Вызов метода на nil-указателе не паникует сам по себе, потому что получатель передаётся в метод как обычный первый аргумент; паника возникает при разыменовании nil, например при обращении к полю.

Источник: https://go.dev/ref/spec#Method_values

### Можно ли определять методы для типов, отличных от структур?

**Да**. Метод можно определить на любом именованном (defined) типе, объявленном в том же пакете: `type Celsius float64`, `type IntSlice []int`, `type Handler func(w http.ResponseWriter, r *http.Request)` — всем им можно дать методы. Это активно используют: например, `time.Duration` — это int64 с методами, а http.HandlerFunc — функциональный тип с методом ServeHTTP.

Источник: https://go.dev/ref/spec#Method_declarations

## Интерфейсы

### Что такое интерфейсы в Go и какова их роль?

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

Источник: https://go.dev/ref/spec#Interface_types

### Как устроены интерфейсы под капотом (iface и eface)?

Интерфейсное значение — это **пара из двух слов**. Для интерфейса с методами это структура **iface**: указатель на itab (таблицу, где лежат тип динамического значения и указатели на его методы) и указатель на сами данные. Для пустого интерфейса — **eface**: указатель на дескриптор типа (\_type) и указатель на данные. Отсюда практические следствия: nil-интерфейс — это когда оба слова нулевые; вызов метода через интерфейс — это косвенный вызов через itab (чуть дороже прямого); а укладка не-указательного значения в интерфейс может потребовать выделения памяти под копию (боксинга): рантайм обходится без него для нулевых и малых неотрицательных целых значений (до 255), а компилятор — для значений, которые не убегают из функции.

Источник: https://go.dev/src/runtime/runtime2.go

### Что представляет собой пустой интерфейс (interface{} / any) и для чего он применяется?

Пустой интерфейс `interface{}` не требует ни одного метода, поэтому ему удовлетворяет любой тип, и переменная такого типа хранит значение чего угодно; с Go 1.18 для него есть псевдоним `any`.

Источник: https://go.dev/ref/spec#Interface_types

### Как компилятор понимает, что тип реализует интерфейс, если наследование неявное?

Компилятор проверяет реализацию структурно и статически: если набор методов типа включает все методы интерфейса с точным совпадением сигнатур, тип считается реализующим интерфейс, ключевое слово `implements` не нужно.

Источник: https://go.dev/ref/spec#Interface_types

## Дженерики

### Как устроены и как работают дженерики (generics) в Go?

Дженерики (Go 1.18) позволяют написать функцию или тип один раз для разных типов: параметр типа объявляется в квадратных скобках вместе с ограничением.

Источник: https://go.dev/doc/tutorial/generics

### Что такое ограничения типов (constraints) и зачем нужен constraint comparable?

Ограничение — интерфейс, который задаёт, какие типы можно подставить в параметр типа; `comparable` разрешает только типы, для которых определены `==` и `!=`.

Источник: https://go.dev/ref/spec#Type_constraints

### Что такое несравниваемые (uncomparable) типы в Go?

Несравнимые типы — те, для которых `==` и `!=` не определены, кроме сравнения с `nil`: срезы, мапы, функции и любые структуры и массивы, содержащие такие поля.

Источник: https://go.dev/ref/spec#Comparison_operators

## Ошибки, panic и recover

### Как в Go принято обрабатывать ошибки и что означает подход «ошибка как значение»?

В Go обычные ошибки не бросаются как исключения: функция возвращает значение типа `error` последним результатом, а вызывающий проверяет его явно.

Источник: https://go.dev/blog/error-handling-and-go

### В чём разница между errors.Is и errors.As?

`errors.Is` проверяет, есть ли в цепочке (дереве) обёрнутых ошибок конкретное значение, а `errors.As` ищет в нём ошибку нужного типа и записывает её в переменную.

Источник: https://pkg.go.dev/errors#Is

### Как обернуть ошибку с сохранением контекста и что делает глагол %w в fmt.Errorf?

Оборачивают через `fmt.Errorf("read config: %w", err)`. Глагол %w (появился в Go 1.13) не просто вставляет текст ошибки, а сохраняет исходную ошибку внутри новой, создавая цепочку: к ней потом применимы errors.Unwrap, errors.Is и errors.As. В отличие от %v, который лишь форматирует текст и теряет связь с оригиналом, %w **позволяет добавить контекст** («что мы делали, когда упало») и при этом сохранить возможность распознать первопричину выше по стеку. С Go 1.20 в одном Errorf можно обернуть несколько ошибок несколькими %w (или errors.Join).

Источник: https://go.dev/blog/go1.13-errors

## defer

### Что такое defer в Go, как он работает и для чего применяется?

defer откладывает вызов функции до момента выхода из окружающей функции — при обычном return, при достижении конца тела функции и при панике. Применяют его для парного освобождения ресурсов рядом с их захватом: открыли файл — тут же `defer f.Close()`, взяли мьютекс — `defer mu.Unlock()`. **Освобождение срабатывает на каждой ветке выхода**: его не нужно дублировать перед каждым return, и оно выполнится даже при панике.

Источник: https://go.dev/blog/defer-panic-and-recover

### В каком порядке выполняются несколько defer, объявленных в одной функции?

Несколько `defer` в одной функции выполняются в обратном порядке объявления (LIFO): последний объявленный отработает первым.

Источник: https://go.dev/ref/spec#Defer_statements

### В какой момент вычисляются аргументы отложенного через defer вызова?

Аргументы defer **вычисляются сразу**, в момент выполнения строки defer, а сам **вызов откладывается**. Поэтому `defer fmt.Println(i)` «запомнит» текущее значение i, и если потом i изменится, напечатается старое. Если нужно взять значение именно на момент выхода, оборачивают в анонимную функцию: `defer func(){ fmt.Println(i) }()` — тут i прочитается позже.

Источник: https://go.dev/ref/spec#Defer_statements

## Горутины и планировщик

### Что такое горутина и чем она отличается от потока операционной системы?

Горутина — лёгкий поток выполнения, которым управляет рантайм Go, а не ядро ОС: множество горутин мультиплексируется на небольшое число потоков ОС (модель M:N).

Источник: https://go.dev/doc/effective_go#goroutines

### За счёт чего горутины легковесны, а их создание обходится так дёшево?

Три причины. Первая — маленький растущий стек: горутина стартует примерно с 2 КБ и увеличивается по мере надобности копированием на больший стек, тогда как поток ОС резервирует мегабайты сразу. Вторая — планирование в user space: рантайм переключает горутины сам, без дорогого системного вызова и перехода в режим ядра. Третья — отсутствие отдельных ядерных ресурсов на каждую горутину: их обслуживает пул потоков ОС. Само создание — это, по сути, выделение маленькой структуры g и постановка её в очередь, поэтому спавнить горутины можно щедро (в отличие от потоков).

Источник: https://go.dev/doc/effective_go#goroutines

### Как устроена модель планировщика G-P-M?

Планировщик Go строится из трёх сущностей: G — горутина, M — поток ОС, который исполняет код, P — логический процессор с локальной очередью готовых горутин и ресурсами для выполнения.

Источник: https://go.dev/src/runtime/proc.go

### Что такое локальные и глобальные очереди горутин и как они взаимодействуют?

У каждого P есть **своя локальная очередь готовых горутин** (небольшая, вместимость 256), а на весь рантайм — **одна глобальная очередь**. Планировщик, ища следующую горутину, сначала заглядывает в локальную очередь своего P (это дёшево и без блокировок), периодически — в глобальную, а если пусто — крадёт работу у других P. Локальные очереди снижают конкуренцию за общий ресурс. Чтобы горутины глобальной очереди не голодали, планировщик время от времени (каждый 61-й тик планировщика на P) принудительно берёт горутину из глобальной очереди — иначе локальные могли бы «зациклиться» на себе.

Источник: https://go.dev/src/runtime/proc.go

### Что такое механизм work stealing в планировщике Go?

Work stealing — способ балансировки нагрузки: когда у P опустела локальная очередь, он забирает примерно половину горутин из локальной очереди другого, случайно выбранного P.

Источник: https://go.dev/src/runtime/proc.go

### Какая многозадачность используется в Go — кооперативная или вытесняющая — и как реализовано вытеснение долгих горутин?

Сейчас планирование в Go вытесняющее: с Go 1.14 рантайм прерывает долгие горутины асинхронно, без их участия.

Источник: https://go.dev/doc/go1.14#runtime

## Каналы и select

### Что такое каналы в Go и для чего они применяются?

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

Источник: https://go.dev/doc/effective_go#channels

### Какие виды каналов существуют в Go?

Каналы различают по двум признакам: буферизации и направлению.

Источник: https://go.dev/ref/spec#Channel_types

### В чём разница между буферизированным и небуферизированным каналом?

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

Источник: https://go.dev/doc/effective_go#channels

### Буферизированный канал с ёмкостью 1 — это то же самое, что небуферизированный?

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

Источник: https://go.dev/ref/spec#Channel_types

### Какие операции с каналами блокируют горутину, а какие нет?

Отправка блокируется, если некому принять (небуферизированный канал) или буфер полон; приём блокируется, если нет готового значения.

Источник: https://go.dev/ref/spec#Send_statements

### Что произойдёт при записи в закрытый канал, чтении из него и повторном закрытии?

Запись в закрытый канал и повторное закрытие паникуют, а чтение из закрытого канала не паникует и не блокируется: отправка в закрытый канал — паника («send on closed channel»), повторное закрытие — паника («close of closed channel»), закрытие nil-канала — тоже паника («close of nil channel»). А вот чтение из закрытого канала безопасно и не блокирует: сначала отдаются все значения, что успели буферизоваться, а затем чтение немедленно возвращает нулевое значение типа, и форма с ok (`v, ok := <-ch`) даёт ok == false.

Источник: https://go.dev/ref/spec#Close

## Примитивы синхронизации

### Что такое мьютекс (sync.Mutex) и для решения каких задач он применяется?

`sync.Mutex` — взаимная блокировка: в каждый момент её удерживает только одна горутина; `Lock` захватывает мьютекс (блокируясь, если он занят), `Unlock` освобождает.

Источник: https://pkg.go.dev/sync#Mutex

### Чем sync.RWMutex отличается от sync.Mutex и когда его предпочтительнее использовать?

`sync.RWMutex` различает блокировку на чтение (`RLock`/`RUnlock`) и на запись (`Lock`/`Unlock`): по документации, блокировку могут удерживать произвольное число читателей или один писатель.

Источник: https://pkg.go.dev/sync#RWMutex

### Могут ли несколько горутин одновременно держать блокировку на чтение в RWMutex?

Да: `RLock` одновременно могут держать сколько угодно горутин, пока нет писателя; блокировка записи `Lock` эксклюзивна, она ждёт освобождения всех читателей и на время удержания никого не пускает.

Источник: https://pkg.go.dev/sync#RWMutex

### Для чего нужна sync.WaitGroup и как с ней работать?

WaitGroup ждёт завершения группы горутин. Работает как счётчик: `Add(n)` увеличивает его на число запускаемых горутин, каждая по завершении вызывает `Done()` (уменьшает на 1, обычно через defer), а `Wait()` блокирует, пока счётчик не станет нулём. Это идиоматичный способ «запустить N задач и дождаться всех». С Go 1.25 запуск задачи есть в самой группе: `wg.Go(task)` сам делает Add(1) и Done, и документация советует предпочитать его ручной паре Add/Done.

Источник: https://pkg.go.dev/sync#WaitGroup

### Почему wg.Add должен вызываться до запуска горутины и к чему приводит нарушение этого правила?

Add нужно вызывать в той же горутине, что запускает новую, до самого `go`. Если сделать Add уже внутри запущенной горутины, возникает гонка с Wait: главная горутина может дойти до Wait и увидеть счётчик нулём (нужный Add ещё не выполнился) — Wait вернётся слишком рано, не дождавшись задач. В итоге программа идёт дальше, пока задачи ещё выполняются, а их результаты не готовы.

Источник: https://pkg.go.dev/sync#WaitGroup.Add

## Конкурентность: гонки, дедлоки, паттерны

### В чём разница между гонкой данных (data race) и состоянием гонки (race condition)?

Гонка данных (data race) — конкретный дефект доступа к памяти: запись в ячейку выполняется одновременно с другим чтением или записью той же ячейки без синхронизации. Состояние гонки (race condition) шире: корректность зависит от относительного порядка событий, даже если каждый доступ к памяти синхронизирован.

Источник: https://go.dev/ref/mem

### К каким последствиям приводит гонка данных и почему?

Гонка данных в Go — ошибка с тяжёлыми последствиями, а не «просто иногда неверное число»: для значения в одно машинное слово исходы ограничены (чтение видит одну из допустимых записей, в отличие от C/C++), но для многословных значений возможна произвольная порча памяти. Последствия: потерянные обновления, чтение «полузаписанного» значения, а для многословных значений (интерфейс, срез и строка занимают несколько машинных слов, а внутреннее состояние мапы состоит из связанных полей) — рассогласованное состояние, способное привести к порче памяти и падению. Одновременную запись в мапу рантайм, если обнаружит, обрывает fatal-ошибкой «concurrent map writes»; обнаружение best-effort, поэтому полагаться на него нельзя. Причина в том, что без синхронизации нет отношения happens-before: компилятор и процессор вправе переупорядочивать и кэшировать операции с памятью, поэтому одна горутина может вообще не увидеть изменений другой либо увидеть их в неожиданном порядке.

Источник: https://go.dev/ref/mem

### Какие механизмы в Go помогают избежать гонки данных?

Гонку данных предотвращает любой механизм, который задаёт отношение happens before между конфликтующими доступами: каналы, мьютексы и атомарные операции.

Источник: https://go.dev/ref/mem

### Как обнаружить гонку данных при разработке?

**Встроенным детектором гонок**: собирать и запускать с флагом `-race` — `go test -race`, `go run -race`, `go build -race`. Он инструментирует обращения к памяти и в рантайме отслеживает отношения happens-before; при обнаружении незащищённого конфликтного доступа печатает отчёт со стеками обоих конфликтующих доступов и стеками, где были созданы затронутые горутины.

Источник: https://go.dev/doc/articles/race_detector

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

Дедлок — состояние, когда горутины навсегда заблокированы, ожидая друг друга или событие, которое не наступит, и ни одна не может продолжить.

Источник: https://go.dev/ref/mem

### Как рантайм Go обнаруживает дедлок?

Рантайм ловит только один частный случай — полный дедлок, когда все горутины заблокированы и ни одна не может продвинуться. Тогда он аварийно завершает программу с сообщением «fatal error: all goroutines are asleep - deadlock!». Но это детекция «всё встало», а не умный анализ: если хотя бы одна горутина работает (например, крутит busy-loop или ждёт сетевой I/O через netpoller), **рантайм дедлок НЕ обнаружит** — частичные взаимоблокировки, где часть горутин навсегда зависла, а остальные живут, проходят незаметно и выглядят как «утечка горутин» или зависший запрос.

Источник: https://go.dev/src/runtime/proc.go

## Пакет context

### Что такое context.Context и для решения каких задач он применяется?

**context.Context** — стандартный способ переносить сигнал отмены, дедлайн и небольшой набор request-scoped значений через границы вызовов и горутин.

Источник: https://pkg.go.dev/context

### Как с помощью context отменить работу горутины и как отмена распространяется?

Отменяемый контекст создаёт `context.WithCancel(parent)`: горутины слушают `ctx.Done()` и сворачиваются, когда кто-то вызвал `cancel()`; отмена идёт вниз по дереву контекстов.

Источник: https://pkg.go.dev/context#WithCancel

### Чем контекст с дедлайном отличается от контекста с таймаутом?

Это один механизм в двух формах: `WithDeadline` принимает абсолютный момент времени, `WithTimeout` принимает длительность от текущего момента и реализован как `WithDeadline(parent, time.Now().Add(timeout))`.

Источник: https://pkg.go.dev/context#WithDeadline

## Память, стек, куча и сборщик мусора

### Что такое стек и куча, в чём их принципиальная разница и почему работа с кучей медленнее?

Стек — область памяти на каждую горутину, работающая по принципу LIFO: кадр функции получает место при входе и отдаёт его при выходе. Куча — общая область для данных, которые живут дольше вызова функции или разделяются между горутинами.

Источник: https://go.dev/doc/gc-guide

### Что такое escape-анализ, кто и когда его выполняет?

Escape-анализ — статический анализ, который компилятор Go выполняет при компиляции: он определяет, выходит ли значение за пределы кадра функции, и от этого зависит, будет ли оно на стеке или в куче.

Источник: https://go.dev/doc/gc-guide

### Как посмотреть, попадёт ли переменная на стек или в кучу?

Решения escape-анализа показывает сам компилятор: `go build -gcflags=-m`, для подробностей `-gcflags=-m=3`.

Источник: https://go.dev/doc/gc-guide

### Почему возврат указателя на локальную переменную приводит к её аллокации в куче?

Если функция возвращает `&local`, то указатель продолжает жить у вызывающего после того, как кадр функции уничтожен. Разместить такую переменную на стеке нельзя — стек кадра освобождается на выходе, и указатель повис бы на невалидной памяти. Поэтому escape-анализ признаёт переменную «убегающей» и размещает её в куче, где она живёт, пока на неё есть ссылки.

Источник: https://go.dev/doc/faq#stack_or_heap

### В каких областях памяти могут аллоцироваться переменные в Go и кто решает где?

Переменные Go размещаются на стеке горутины или в куче, и место выбирает компилятор, а не программист.

Источник: https://go.dev/doc/faq#stack_or_heap

### Какой алгоритм использует сборщик мусора в Go и как он работает?

Сборщик мусора Go — трассирующий, конкурентный, трёхцветный, mark-and-sweep, неперемещающий и без поколений.

Источник: https://go.dev/doc/gc-guide

## Стандартная библиотека и рантайм

### Как работает сериализация в encoding/json, за что отвечают теги структур и когда важно проверять ошибку маршалинга?

`json.Marshal` рекурсивно обходит значение и кодирует его в JSON, `json.Unmarshal` делает обратное; поведением полей управляют теги структуры, а ошибку нужно проверять всегда.

Источник: https://pkg.go.dev/encoding/json

### Что такое рефлексия (пакет reflect), для чего она нужна и почему считается медленной?

Рефлексия (пакет `reflect`) позволяет программе во время выполнения исследовать типы и значения, не зная их статически: `reflect.TypeOf` и `reflect.ValueOf` дают доступ к типу и значению.

Источник: https://pkg.go.dev/reflect

### Какие возможности предоставляет пакет runtime для интроспекции программы?

Для интроспекции runtime даёт сведения о среде (NumGoroutine — число существующих горутин, NumCPU — число логических процессоров, доступных процессу, GOMAXPROCS(0) — текущий предел числа процессоров, на которых одновременно исполняется Go-код, а также Version, GOOS и GOARCH), статистику памяти (ReadMemStats — куча и GC через структуру MemStats) и стеки вызовов (Stack, Caller, Callers); профили и трассировку дают runtime/pprof и runtime/trace. Для управления выполнением есть Gosched (уступить процессор), GC (форсировать сборку), SetFinalizer и KeepAlive (достижимость объектов; в новом коде вместо SetFinalizer рекомендуется AddCleanup, Go 1.24).

Источник: https://pkg.go.dev/runtime

## Тестирование

### Чем модульный (unit) тест принципиально отличается от интеграционного?

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

Источник: https://pkg.go.dev/testing

### Какие подходы и инструменты используются для написания тестов в Go?

Основа тестирования в Go — встроенный пакет `testing` и команда `go test`.

Источник: https://pkg.go.dev/testing

### Что такое table-driven тесты и почему это идиоматичный подход в Go?

Table-driven тест — это когда набор случаев описывают как срез структур (обычно поля: имя случая, входные данные, ожидаемый результат), а затем в цикле прогоняют каждый случай, запуская его как подтест через t.Run(tc.name, func(t *testing.T) { ... }).

Источник: https://pkg.go.dev/testing

### Зачем нужны моки при тестировании и какие инструменты их генерации существуют?

**Мок** — это тестовый двойник зависимости, который реализует тот же интерфейс, что и настоящая зависимость, но с управляемым поведением: он нужен, чтобы протестировать единицу кода в изоляции — не ходить в реальную базу или сеть, задать нужные ответы и при необходимости проверить, что и с какими аргументами было вызвано. В Go это опирается на маленькие интерфейсы и принцип «принимай интерфейсы»: код зависит от интерфейса, а в тест подставляется двойник. Часто достаточно написать двойник руками (простой фейк или стаб — идиоматично и без зависимостей). Для генерации есть инструменты: go.uber.org/mock (mockgen, наследник gomock) и mockery, который создаёт моки под testify/mock; сам пакет testify/mock ничего не генерирует, моки в нём пишут вручную.

Источник: https://pkg.go.dev/go.uber.org/mock/gomock

### Как реализовать проверки (assertions) в тестах, используя только стандартную библиотеку testing?

В пакете testing намеренно нет функций-ассертов: проверку пишут вручную обычным if и при несовпадении вызывают **t.Errorf** (пометить провал и продолжить) или t.Fatalf (сообщить и остановить тест). Базовый шаблон — «if got != want { t.Errorf("Foo() = %v, want %v", got, want) }». Для сравнения сложных значений (срезы, мапы, структуры) берут reflect.DeepEqual (а для срезов и мап ещё slices.Equal и maps.Equal); если внешняя зависимость допустима, google/go-cmp (не входит в стандартную библиотеку) через cmp.Diff даёт читаемый дифф несовпадения. Общие проверки удобно вынести во вспомогательную функцию и пометить её t.Helper(), тогда сообщение об ошибке укажет на строку вызова в тесте, а не внутрь помощника.

Источник: https://pkg.go.dev/testing

## Профилирование и инструменты

### Для чего используется pprof и что можно увидеть с его помощью?

`pprof` — семплирующий профилировщик Go и инструмент `go tool pprof`, который показывает, на что программа тратит ресурсы, и помогает найти горячие точки.

Источник: https://go.dev/blog/pprof

### Как подключить и использовать pprof в веб-сервисе на Go?

В веб-сервисе pprof подключают импортом ради побочного эффекта: **import \_ "net/http/pprof"** — этот импорт регистрирует HTTP-обработчики по путям /debug/pprof/ на стандартном мультиплексоре. Если своего HTTP-сервера нет, поднимают отдельный (например, go func() { http.ListenAndServe("localhost:6060", nil) }()). Дальше профили снимают инструментом go tool pprof прямо по URL: go tool pprof http://localhost:6060/debug/pprof/heap для кучи, http://localhost:6060/debug/pprof/profile?seconds=30 для 30-секундного CPU-профиля, http://localhost:6060/debug/pprof/goroutine для стеков горутин; block- и mutex-профили заработают после включения через runtime.SetBlockProfileRate и runtime.SetMutexProfileFraction. По пути **/debug/pprof/trace?seconds=5** забирают execution trace для go tool trace. С Go 1.22 все эти эндпоинты обслуживают только GET. Если сервис использует собственный мультиплексор, а не DefaultServeMux, обработчики нужно зарегистрировать на нём вручную.

Источник: https://pkg.go.dev/net/http/pprof

### Почему постоянное профилирование через pprof не рекомендуется в production?

Профилировать production можно (документация Go считает это безопасным), но держать профили включёнными постоянно и выставлять /debug/pprof/ наружу не стоит: эндпоинты раскрывают внутренности процесса, а часть профилей стоит производительности. Эндпоинты /debug/pprof/ раскрывают внутренности процесса: командную строку, стеки всех горутин, карту памяти. Открыть их в публичный интернет — значит отдать чувствительную информацию и получить вектор DoS (снятие профиля само нагружает сервис), поэтому их нельзя выставлять наружу без аутентификации, а лучше держать на отдельном внутреннем порту.

Источник: https://pkg.go.dev/net/http/pprof

## Модули и сборка

### Для чего нужны файлы go.mod и go.sum?

`go.mod` описывает модуль и его зависимости, а `go.sum` хранит контрольные суммы этих зависимостей для проверки целостности.

Источник: https://go.dev/ref/mod

### Во что компилируется программа на Go и что такое статическая линковка?

go build компилирует исходный код Go в машинный код и линкует его в один исполняемый файл. По умолчанию бинарник статически слинкован: все Go-зависимости и сам рантайм Go (включая сборщик мусора и планировщик) вшиты внутрь файла, внешних .so/динамических Go-зависимостей нет. Практическое следствие — деплой сводится к копированию одного самодостаточного файла, что особенно удобно для контейнеров (например, образ from scratch). Статическая линковка означает, что зависимый код включён в бинарник на этапе сборки, а не подгружается динамически при запуске.

Источник: https://pkg.go.dev/cmd/go

### Как выполнить кросс-компиляцию под другую ОС и архитектуру с помощью GOOS и GOARCH?

Кросс-компиляция в Go делается заданием двух переменных окружения перед сборкой: **GOOS** — целевая операционная система (например, linux, windows, darwin), **GOARCH** — целевая архитектура (amd64, arm64, 386 и др.). Например, GOOS=linux GOARCH=arm64 go build соберёт бинарник под Linux/ARM64 прямо с вашей машины. Для чистого Go-кода это работает без целевой машины и без установки отдельного тулчейна: компилятор Go умеет генерировать код под все поддерживаемые платформы «из коробки», а результат — самодостаточный статический бинарник. Список допустимых пар GOOS/GOARCH фиксирован для версии Go. Основная сложность — cgo: там для сборки под другую платформу нужен кросс-компилятор C, поэтому при кросс-сборке часто ставят `CGO_ENABLED=0`. Простота кросс-компиляции — одна из заметных сильных сторон Go.

Источник: https://pkg.go.dev/cmd/go

### Как работает функция init и в каком порядке инициализируются пакеты?

`init` — специальная функция без параметров и результатов (`func init()`), которую вызывает рантайм при инициализации пакета; зависимые пакеты инициализируются раньше импортирующих.

Источник: https://go.dev/ref/spec#Package_initialization

### Как в Go-модулях работает версионирование зависимостей?

Зависимости версионируются по semver (`vMAJOR.MINOR.PATCH`), а нужные версии выбирает алгоритм minimal version selection (MVS): `go` берёт для каждого модуля наибольшую из минимально требуемых версий в графе зависимостей, а не самую свежую.

Источник: https://go.dev/ref/mod

## HTTP-сервер и net/http

### Чем интерфейс http.Handler отличается от http.HandlerFunc?

`http.Handler` — интерфейс с единственным методом `ServeHTTP(ResponseWriter, *Request)`, а `http.HandlerFunc` — тип-функция, которая этот интерфейс реализует и превращает обычную функцию в `Handler`. Любой тип, реализующий интерфейс, может обслуживать запросы.

Источник: https://pkg.go.dev/net/http#Handler

### Как устроена маршрутизация в http.ServeMux и что изменилось в Go 1.22?

`ServeMux` сопоставляет запрос с зарегистрированным шаблоном. Исторически он умел немного: точные пути и префиксы, заканчивающиеся на `/`, причём выигрывал самый длинный совпавший префикс, а метод запроса не учитывался вовсе.

Источник: https://go.dev/doc/go1.22

### Почему важен порядок вызовов при записи ответа через http.ResponseWriter?

Заголовки уходят клиенту в момент, когда впервые записывается тело или явно вызывается `WriteHeader`. После этого менять `w.Header()` бессмысленно: изменения никуда не попадут, а повторный `WriteHeader` вызовет предупреждение о «superfluous WriteHeader».

Источник: https://pkg.go.dev/net/http#ResponseWriter

## Middleware и композиция обработчиков

### Как реализуется middleware в Go и почему это просто функция?

Middleware — функция вида `func(http.Handler) http.Handler`: она принимает обработчик и возвращает новый, который что-то делает до и после вызова вложенного.

Источник: https://pkg.go.dev/net/http#Handler

### Почему порядок middleware имеет значение — на конкретных примерах?

Потому что каждый слой решает, вызывать ли следующий, и видит только то, что произошло внутри него.

Источник: https://pkg.go.dev/net/http#Handler

### Что произойдёт при панике в обработчике и зачем свой recover?

`net/http` сам восстанавливается после паники в обработчике: сервер логирует стек и закрывает соединение (в HTTP/2 сбрасывает поток), но процесс не падает. Однако клиент при этом получает разрыв, а не осмысленный ответ, и в логе оказывается лишь стандартное сообщение.

Источник: https://pkg.go.dev/net/http#Handler

## JSON и сериализация

### Как теги структуры управляют кодированием в JSON?

Тег `json` задаёт имя поля и опции: `json:"user_id"` переименовывает, `json:"-"` исключает поле полностью, `json:",omitempty"` пропускает поле при нулевом значении.

Источник: https://pkg.go.dev/encoding/json#Marshal

### Во что превращается произвольный JSON при разборе в interface{}?

В фиксированный набор типов: объект — в `map[string]interface{}`, массив — в `[]interface{}`, строка — в `string`, логическое — в `bool`, `null` — в `nil`, а **любое число — в `float64`**.

Источник: https://pkg.go.dev/encoding/json#Unmarshal

### Как задать собственное представление типа в JSON?

Реализовать `json.Marshaler` — метод `MarshalJSON() ([]byte, error)` — и симметрично `json.Unmarshaler` с методом `UnmarshalJSON([]byte) error`. Кодировщик вызовет их вместо стандартного поведения.

Источник: https://pkg.go.dev/encoding/json#Marshaler

## Доступ к данным

### Сервис на Go с database/sql под нагрузкой упёрся в max_connections PostgreSQL. Какие настройки пула вы проверите и какие у них значения по умолчанию?

Проверяют `SetMaxOpenConns`, `SetMaxIdleConns`, `SetConnMaxLifetime` и `SetConnMaxIdleTime` у `*sql.DB`.

Источник: https://go.dev/doc/database/manage-connections

### Почему после db.QueryContext в Go нужно закрывать rows и проверять rows.Err, и что случится, если ранний return выйдет из цикла по строкам?

Пока `Rows` не закрыт, он удерживает соединение пула, поэтому незакрытые `Rows` исчерпывают пул, и новые запросы будут ждать бесконечно.

Источник: https://pkg.go.dev/database/sql#Rows

### Как правильно написать транзакцию в Go через database/sql с контекстом, чтобы при ошибке и при отмене запроса она откатывалась, а внутри использовалась одна и та же транзакция?

Начинают транзакцию `tx, err := db.BeginTx(ctx, nil)`, сразу откладывают `defer tx.Rollback()` и вызывают `tx.Commit()` в конце; все запросы внутри идут через `tx.ExecContext`/`tx.QueryContext`, а не через `db`.

Источник: https://pkg.go.dev/database/sql#DB.BeginTx

## HTTP API: условные запросы и версии

### Как в Go-обработчике ответить 304 Not Modified, если клиент прислал If-None-Match с актуальным ETag?

Нужно вычислить ETag ресурса, сравнить его с заголовком `If-None-Match` и при совпадении вернуть 304 без тела; в остальных случаях отдать ответ с заголовком `ETag`.

Источник: https://pkg.go.dev/net/http#ServeContent

### Какие изменения REST API считаются ломающими, как вынести версию в путь /v1/ в Go на стандартном ServeMux и когда пора заводить /v2/?

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

Источник: https://pkg.go.dev/net/http#StripPrefix

### Обработчик вызывает `http.ServeContent` и перед вызовом ставит `ETag: "v7"`, время изменения содержимого передано 19 октября 2026 12:00:00 UTC. Клиент присылает `GET` с заголовками `If-None-Match: "v6"` и `If-Modified-Since: Mon, 19 Oct 2026 12:00:01 GMT`. Что ответит `ServeContent` и почему?

Полный ответ `200` с телом: `If-Modified-Since` при наличии `If-None-Match` не учитывается.

Источник: https://pkg.go.dev/net/http

## Конфигурация и отказоустойчивость

### Что принцип «Config» из методологии twelve-factor считает конфигурацией, где её хранить и как проверить, что граница проведена верно?

Конфигурация это всё, что отличается между развёртываниями (staging, production): адреса БД и сервисов, учётные данные, ключи внешних API. Её хранят в переменных окружения, а не в коде и не в файлах репозитория.

Источник: https://12factor.net/config

### В Go-сервисе os.Getenv вызывается в десятке мест, а отсутствие обязательной переменной обнаруживается только при первом обращении. Как организовать загрузку конфигурации?

Читать окружение один раз при старте в единую структуру `Config`, проверять её и передавать зависимостям явно; при ошибке сервис не запускается.

Источник: https://12factor.net/config

### Как в Go написать повтор вызова внешнего сервиса при ошибке 503, чтобы он не усугублял перегрузку, и что делать с отменой контекста во время ожидания?

Повторять ограниченное число раз с экспоненциально растущей паузой, добавлять случайный разброс (jitter), ограничивать максимум паузы и прерывать ожидание по отмене контекста.

Источник: https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/

## Наблюдаемость

### Как с помощью log/slog записать запись с типизированными атрибутами и сгруппировать часть из них под общим ключом, и как это выглядит в JSON?

Сообщение и пары ключ-значение передают в `logger.Info`, группу создают `slog.Group`, постоянные атрибуты привязывают `logger.With`.

Источник: https://pkg.go.dev/log/slog

### Как добавить в каждую запись slog идентификатор трассировки из context.Context, не передавая его вручную в каждый вызов?

Вызывать методы с контекстом (`logger.InfoContext(ctx, ...)`) и обернуть обработчик своим `slog.Handler`, который достаёт значение из `ctx` и добавляет его атрибутом в `Handle`.

Источник: https://pkg.go.dev/log/slog#Handler

### Как трассировка OpenTelemetry связывает спаны двух сервисов на Go, когда один вызывает другой по HTTP?

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

Источник: https://opentelemetry.io/docs/languages/go/instrumentation/

## gRPC в Go

### Чем `grpc.NewClient` отличается от `grpc.Dial` и `grpc.DialContext`: когда устанавливается соединение, какой резолвер используется по умолчанию и что станет с опцией `WithBlock`?

`NewClient` создаёт канал без ввода-вывода и соединяется при первом вызове, а `Dial` и `DialContext` устарели: они начинают соединяться сразу, по умолчанию берут резолвер `passthrough` и поддерживают `WithBlock`, который `NewClient` игнорирует.

Источник: https://pkg.go.dev/google.golang.org/grpc#NewClient

### При остановке сервис вызывает `server.GracefulStop()`, но процесс не завершается, пока открыт серверный поток подписки. Почему и как ограничить время остановки?

`GracefulStop` блокируется, пока не завершатся все идущие вызовы, а серверный поток подписки сам не заканчивается, поэтому метод не возвращается. Время ограничивают отдельным таймером, по которому вызывают `Stop`.

Источник: https://pkg.go.dev/google.golang.org/grpc#Server.GracefulStop

### Обработчик сервиса заказов вызывает сервис оплаты с тем же `ctx`. Дедлайн дошёл до сервиса оплаты, а заголовок `x-request-id` из входящих метаданных — нет. Почему и как его передать?

Дедлайн хранится в самом `ctx`, а метаданные входящего и исходящего вызова лежат в контексте раздельно: исходящий вызов берёт заголовки только из исходящих метаданных, и входящие туда сами не попадают. Заголовок копируют явно: читают из входящих и добавляют в исходящие.

Источник: https://pkg.go.dev/google.golang.org/grpc/metadata
