Как проходит собеседование на Go-разработчика
Обычно это скрининг с рекрутером, техническое интервью (язык и рантайм, базы данных, HTTP, иногда очереди вроде Kafka), live coding или code review и для middle и senior секция проектирования систем. Как подготовиться к каждой секции и рассуждать вслух, разобрано в статье про техническое собеседование.
Middle и senior отличаются не тем, что знают ответ, а тем, что понимают, почему так устроено и чем это грозит в проде. Поэтому к каждому ответу полезно добавить случай из практики.
Горутины и планировщик
1. Чем горутина отличается от потока ОС?
Что проверяют: понимание модели конкурентности Go.
Горутиной управляет рантайм Go, а не ядро. Она стартует с маленьким стеком (килобайты), который растёт и уменьшается по мере надобности, поэтому горутин могут быть сотни тысяч. Переключение между ними происходит в пространстве пользователя и стоит дешевле, чем переключение потоков. Рантайм выполняет горутины на небольшом числе потоков ОС.
2. Как устроен планировщик Go?
Что проверяют: знание модели GMP.
G: горутина, M: поток ОС, P: логический процессор с локальной очередью горутин. Чтобы выполнять Go-код, поток должен владеть P, а число P равно GOMAXPROCS. Есть и глобальная очередь, а простаивающий P крадёт работу у других (work stealing). Если горутина ушла в блокирующий системный вызов, P передают другому потоку. Сетевые операции идут через netpoller и поток не блокируют. С Go 1.14 есть асинхронное вытеснение, поэтому цикл без вызовов функций не держит P вечно.
3. Что такое GOMAXPROCS и что с ним в контейнере?
Что проверяют: опыт эксплуатации Go-сервисов.
Это число P, то есть сколько потоков одновременно выполняют Go-код. По умолчанию равно числу доступных CPU. Раньше в контейнере Go видел все ядра хоста, а не лимит CPU, из-за чего сервис упирался в троттлинг, и ставили библиотеку automaxprocs. Начиная с Go 1.25 рантайм на Linux сам учитывает лимит CPU из cgroup.
4. Как возникает утечка горутин и как её найти?
Что проверяют: опыт с реальными проблемами в проде.
Горутина навсегда блокируется: пишет в канал, который никто не читает, или ждёт без таймаута. Типичный случай: функция запускает горутину, которая отправляет результат в небуферизованный канал, а вызывающий код уже вышел по таймауту. Лечат буфером на один элемент для результата, контекстом с отменой и select с ctx.Done(). Находят по метрике runtime.NumGoroutine(), профилю goroutine в pprof, в тестах помогает библиотека goleak.
Каналы и select
5. Чем небуферизованный канал отличается от буферизованного?
Что проверяют: понимание синхронизации.
В небуферизованном канале отправка блокируется, пока получатель не заберёт значение: это точка встречи двух горутин. В буферизованном отправка блокируется только при полном буфере, чтение только при пустом. Буфер не исправляет ошибки синхронизации, а сглаживает неравномерность, и его размер нужно уметь обосновать.
6. Что будет при операциях с nil-каналом и закрытым каналом?
Что проверяют: знание граничных случаев, на них строят задачи.
| Операция | nil-канал | Закрытый канал |
|---|---|---|
| Отправка | Блокируется навсегда | panic |
| Чтение | Блокируется навсегда | Сначала остаток буфера, затем нулевое значение и ok == false |
| Закрытие | panic | panic |
Форма v, ok := <-ch отличает закрытие от настоящего нулевого значения, а for range ch завершается, когда канал закрыт и буфер вычитан.
7. Как работает select?
Что проверяют: умение строить конкурентную логику.
Select ждёт, пока одна из операций с каналами станет возможной, и выполняет её. Если готовы несколько, выбирается случайная, чтобы ни одна ветка не голодала. Ветка default делает select неблокирующим, пустой select {} блокирует навсегда. Приём: присвоить переменной канала nil, чтобы отключить ветку, когда входной канал уже закрыт. Таймауты делают через ctx.Done() или time.After.
8. Кто должен закрывать канал?
Что проверяют: понимание владения каналом.
Отправитель, и только когда точно ничего больше не отправит. Если закроет получатель, отправитель получит panic. При нескольких отправителях их ждут через sync.WaitGroup, а канал закрывает отдельная горутина после wg.Wait(). Закрывать канал нужно, только если получатель ждёт сигнала завершения: незакрытый канал сборщик мусора тоже освободит.
Синхронизация
9. Когда каналы, а когда мьютекс?
Что проверяют: инженерный выбор, а не религию.
Каналы для передачи данных и владения ими между горутинами, конвейеров и сигналов. Мьютекс для защиты общего состояния: кеша, счётчика, мапы. Принцип «делитесь памятью через общение» не запрещает мьютексы: для счётчика sync.Mutex или sync/atomic проще и быстрее канала. RWMutex оправдан, когда чтений намного больше, чем записей.
10. Что такое гонка данных и как её найти?
Что проверяют: культуру конкурентного кода.
Гонка: две горутины обращаются к одной переменной без синхронизации, и хотя бы одна пишет. Это ошибка, даже если «всё работает». Находят детектором: go test -race или сборка с -race на стенде. Он ловит только гонки, которые реально случились во время выполнения, поэтому нужны тесты с конкурентной нагрузкой.
11. Как запустить N задач параллельно и получить первую ошибку?
Что проверяют: знание стандартных инструментов.
errgroup.WithContext из golang.org/x/sync: каждую задачу запускают через g.Go, g.Wait() возвращает первую ошибку, а общий контекст отменяется, чтобы остальные задачи остановились. Параллелизм ограничивает g.SetLimit(n). Если ошибки не нужны, хватит sync.WaitGroup, в Go 1.25 у него появился метод Go.
Слайсы, мапы и строки
12. Как устроен слайс?
Что проверяют: знание внутреннего устройства, без него не решить задачи на append.
Заголовок из трёх полей: указатель на базовый массив, длина и ёмкость. При передаче копируется заголовок, массив остаётся общим. append пишет в тот же массив, если хватает ёмкости, иначе выделяет новый (небольшие слайсы растут примерно вдвое, большие медленнее) и копирует данные. Поэтому результат append всегда присваивают. Если размер известен, ёмкость задают сразу: make([]T, 0, n).
13. Что выведет код?
Что проверяют: применение знаний о слайсах.
a := []int{1, 2, 3, 4}; b := a[:2]; b = append(b, 99); fmt.Println(a)
Выведет [1 2 99 4]. У b длина 2 и ёмкость 4, поэтому append записал 99 в общий массив поверх a[2]. Чтобы получить независимый слайс, используют copy, slices.Clone или полное выражение среза a[:2:2]: оно ограничит ёмкость, и append выделит новый массив.
14. Как устроена map и почему порядок обхода случайный?
Что проверяют: знание мап и их ограничений.
Это хеш-таблица, с Go 1.24 на основе Swiss Tables. Ключ должен быть сравнимым типом: слайс, мапа или функция ключом быть не могут. Порядок обхода не гарантирован и специально рандомизирован, чтобы на него не полагались. Чтение из nil-мапы возвращает нулевое значение, запись вызывает panic. Взять адрес элемента (&m[k]) или присвоить полю структуры внутри мапы (m[k].x = 1) нельзя: элементы могут переезжать при росте таблицы.
15. Что будет при одновременной записи в map из нескольких горутин?
Что проверяют: понимание потокобезопасности.
Мапа не потокобезопасна. Рантайм обнаруживает часть таких ситуаций и завершает программу с fatal error: concurrent map writes: это не panic, recover его не перехватит. Защищают мапу через sync.Mutex или sync.RWMutex. sync.Map подходит для частных случаев: ключ записывается один раз и много читается или горутины работают с непересекающимися ключами.
16. Чему равно len("привет") и как перебрать символы строки?
Что проверяют: понимание строк и UTF-8.
12: len возвращает число байт, а кириллическая буква в UTF-8 занимает два байта. Строка неизменяема, внутри это байты. for i, r := range s перебирает руны (тип rune является алиасом int32), а i будет индексом первого байта руны. Число символов даёт utf8.RuneCountInString(s), а s[i] возвращает байт, а не символ.
Интерфейсы и дженерики
17. Как устроены интерфейсы в Go?
Что проверяют: понимание неявной реализации.
Тип реализует интерфейс неявно: достаточно иметь нужные методы. Поэтому интерфейсы принято объявлять на стороне потребителя и делать маленькими, как io.Reader. Значение интерфейса хранит две части: информацию о динамическом типе (для непустого интерфейса это таблица методов itab) и указатель на данные.
18. Почему интерфейс с nil-указателем не равен nil?
Что проверяют: классическую ловушку.
var p *MyErr = nil; var err error = p; fmt.Println(err == nil) выведет false. Интерфейс равен nil, только когда пусты и тип, и значение, а здесь тип записан. Следствие: функция, которая возвращает error, должна возвращать литерал nil, а не типизированный nil-указатель.
19. Чем отличается получатель-значение от получателя-указателя?
Что проверяют: знание наборов методов.
Указатель нужен, если метод меняет состояние или структура большая, получатель-значение работает с копией. Набор методов типа T содержит только методы с получателем-значением, а *T содержит оба вида. Поэтому, если Area объявлен на *Circle, то var s Shape = Circle{} не скомпилируется, нужен &Circle{}.
20. Когда дженерики, а когда интерфейсы?
Что проверяют: умение не усложнять.
Дженерики нужны для кода, который одинаково работает с разными типами данных: контейнеры, функции над слайсами и мапами (пакеты slices и maps). Интерфейсы нужны для поведения, которое разные типы реализуют по-разному. Ограничения задаются интерфейсами: comparable, cmp.Ordered, наборы вроде ~int | ~int64. Если дженерик не убирает дублирование, лучше обойтись без него.
Ошибки, panic и defer
21. Как в Go принято обрабатывать ошибки?
Что проверяют: идиоматичность кода.
Ошибка: обычное значение, которое возвращают последним и проверяют сразу. Её либо обрабатывают, либо возвращают с контекстом: fmt.Errorf("загрузка заказа %d: %w", id, err). errors.Is сравнивает с sentinel-ошибкой (например, sql.ErrNoRows) по всей цепочке обёрток, errors.As достаёт ошибку нужного типа, errors.Join объединяет несколько. Одну ошибку не стоит и логировать, и возвращать: она попадёт в логи дважды.
22. Когда уместны panic и recover?
Что проверяют: понимание границ механизма.
Panic для ошибок программиста и невозможных ситуаций: нарушенный инвариант, неудачная инициализация при старте (regexp.MustCompile). Ожидаемые ошибки возвращают через error. recover работает только внутри отложенной функции и только в той горутине, где случилась паника. Поэтому panic в фоновой горутине без recover роняет весь процесс. net/http восстанавливает паники в обработчиках, а свои горутины нужно защищать самим.
23. Как работает defer?
Что проверяют: знание порядка выполнения и ловушек.
Отложенные вызовы выполняются при выходе из функции в обратном порядке. Аргументы вычисляются в момент объявления defer, а не при выполнении. Отложенная функция может изменить именованные возвращаемые значения, на этом строят обработку ошибки Close. Ловушка: defer в цикле копит вызовы до конца функции, и файлы остаются открытыми, поэтому тело цикла выносят в отдельную функцию.
Context
24. Зачем нужен context и как им пользоваться правильно?
Что проверяют: умение писать сервисы, которые корректно отменяются.
Context передаёт отмену, дедлайны и данные уровня запроса. Правила: первый аргумент ctx context.Context, не хранить в структурах, не передавать nil (если контекста нет, context.TODO()), всегда вызывать cancel из WithCancel и WithTimeout (обычно через defer), в долгих операциях проверять ctx.Done(). В WithValue кладут только сквозные данные запроса (request ID, данные авторизации) с ключом собственного неэкспортируемого типа.
25. Что будет, если не вызвать cancel?
Что проверяют: понимание ресурсов контекста.
Ресурсы контекста (таймер, связь с родителем) не освободятся, пока не отменится родитель или не истечёт таймаут. В долгоживущем сервисе это медленная утечка памяти, go vet предупреждает о ней проверкой lostcancel. Отмена родителя отменяет всех потомков, отмена потомка на родителя не влияет.
Память и сборщик мусора
26. Где выделяется память: на стеке или в куче?
Что проверяют: понимание escape analysis и цены аллокаций.
Решает компилятор: если значение не переживает функцию, оно живёт на стеке, иначе «убегает» в кучу. Типичные причины: возврат указателя на локальную переменную, захват замыканием, сохранение в интерфейс, большой или неизвестный при компиляции размер. Решения компилятора видны через go build -gcflags=-m, аллокации в горячем коде через бенчмарки с -benchmem.
27. Как работает сборщик мусора в Go?
Что проверяют: знание рантайма и умение его настраивать.
Конкурентный mark-and-sweep с трёхцветной маркировкой: большая часть работы идёт параллельно с программой, паузы с остановкой мира короткие. Барьер записи не даёт потерять объекты, которые программа меняет во время маркировки. Сборщик не поколенческий и не перемещает объекты. Настройки: GOGC (по умолчанию 100: следующий цикл начнётся, когда куча вырастет на 100% от живых данных после прошлой сборки) и GOMEMLIMIT, мягкий лимит памяти, который в контейнере ставят чуть ниже лимита пода. Нагрузку на GC снижают, уменьшая число аллокаций: предвыделение слайсов, переиспользование буферов, sync.Pool.
28. Как понять, почему сервис тормозит или ест память?
Что проверяют: навык профилирования.
pprof: подключить net/http/pprof или снять профиль в тестах и бенчмарках. CPU-профиль показывает горячие функции, heap показывает, кто держит память и кто много выделяет, goroutine показывает зависшие горутины, mutex и block показывают конкуренцию за блокировки. Анализ через go tool pprof и flame graph, задержки планировщика и паузы GC видны в go tool trace.
Практические задачи
- «Что выведет код». Append и общий массив, интерфейс с nil-указателем, порядок defer, чтение из закрытого канала, замыкания в цикле. Про цикл скажите о двух поведениях: с Go 1.22 переменная цикла новая на каждой итерации, а раньше горутины в цикле видели одну переменную и часто печатали последнее значение.
- Конкурентность. Worker pool с ограничением параллелизма, слияние нескольких каналов в один (fan-in), параллельные HTTP-запросы с общим таймаутом и отменой при первой ошибке, rate limiter.
- Структуры данных. LRU-кеш (мапа плюс двусвязный список), потокобезопасный кеш с TTL.
- Code review. Найти гонку, утечку горутины, проигнорированную ошибку, defer в цикле, незакрытое тело HTTP-ответа.
- Проектирование. Сервис коротких ссылок, рассылка уведомлений, обработка заказов из Kafka.
На live coding сначала уточните условия и проговорите план, затем напишите простую рабочую версию и только потом улучшайте. В задачах на конкурентность заранее скажите, кто и когда закрывает каждый канал и как всё остановится при отмене контекста. Типичный каркас worker pool: канал задач, N воркеров, которые читают его через for range, WaitGroup и отдельная горутина, закрывающая канал результатов после wg.Wait().
HR-часть и вопросы работодателю
Рекрутер и тимлид спросят про проекты: нагрузку, архитектуру (монолит или микросервисы), базы, брокеры, наблюдаемость. Подготовьте одну историю о проекте с цифрами:
Делал сервис расчёта стоимости доставки, в пике около 3 тысяч запросов в секунду. По профилю pprof нашёл лишние аллокации при сериализации и N+1 запросы к PostgreSQL, после исправлений p99 снизился с 400 до 120 мс.
Если вы переходите в Go с другого языка, скажите об этом прямо и покажите pet-проект. Сравнить ожидания по стеку помогут соседние разборы для Java и DevOps.
Что спросить самому:
- Какая версия Go и как часто обновляются.
- Сколько сервисов у команды и кто их дежурит.
- Как устроены code review, тесты и релизы.
- Какая доля легаси и есть ли время на технический долг.
Ещё идеи в подборке вопросов работодателю.
Как отрепетировать
Знать про GMP и объяснить его за минуту вслух: это разные навыки. Отвечайте на вопросы из статьи с таймером, по 1-2 минуты, и записывайте себя, чтобы услышать, где начинаете плавать. Задачи «что выведет код» сначала решайте в голове, проговаривая рассуждение, потом проверяйте в Go Playground. Live coding тренируйте с другом, который перебивает уточняющими вопросами, или в Собесе, где голосовой ИИ-интервьюер проводит собеседование по вакансии с hh.ru и после звонка разбирает ответы.
Частые вопросы
Какие вопросы задают junior Go-разработчику?
Основы языка: типы, слайсы и мапы, структуры и методы, интерфейсы, обработку ошибок, горутины и каналы на базовом уровне, плюс SQL и HTTP. Часто дают «что выведет код» и простую задачу на слайсы или мапы. Про планировщик и GC у джунов спрашивают реже, но базовое понимание выделит вас среди других кандидатов.
Что спрашивают у middle и senior?
Устройство рантайма (планировщик, GC, escape analysis), паттерны конкурентности и их ошибки, профилирование, работу с базами под нагрузкой, проектирование сервисов. Обязательно спросят про реальные проблемы: утечки, гонки, деградацию под нагрузкой. Ответы без опыта из практики на этом уровне звучат слабо даже при хорошей теории.
Нужно ли решать алгоритмические задачи?
В крупных компаниях часто да: секция с задачами на массивы, хеш-таблицы и строки. В продуктовых командах чаще дают прикладную задачу на конкурентность или code review. Формат лучше уточнить у рекрутера заранее.
Можно ли перейти в Go с другого языка?
Да, многие Go-разработчики пришли из PHP, Python или Java. Покажите pet-проект на Go с горутинами, тестами и работой с базой и будьте готовы к вопросам про отличия: явные ошибки вместо исключений, композиция вместо наследования, неявные интерфейсы. Опыт с базами, сетями и архитектурой переносится полностью.
Какие изменения в Go стоит знать?
Дженерики, новую семантику переменной цикла, пакеты slices и maps, итераторы через range по функциям, контейнерный GOMAXPROCS. Если в компании старая версия Go, вас могут спросить, как было раньше, особенно про замыкания в цикле. Release notes последних версий стоит пролистать перед собеседованием.
