Как отвечать: определение → как работает внутри → где ловушка → пример. Отвечайте вслух до чтения ответа — собеседование это устный жанр, и «понимаю про себя» не равно «объясняю словами».
1. Задача 1: разверните строку («Привет» → «тевирП»). В чём ловушка?
Ловушка — байты против рун. Если строку конвертировать в []byte и развернуть, многобайтовые символы кириллицы и эмодзи разъезжаются на мусор: каждый кириллический символ занимает два байта UTF-8, и побайтовый разворот ставит байты одного символа в неправильном порядке. Правильное решение — конвертировать в []rune: рун-слайс это []rune(s) разбирает строку на кодовые точки, разворот переставляет целые символы, и string() собирает их обратно в корректный UTF-8.
func reverse(s string) string {
r := []rune(s)
for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
r[i], r[j] = r[j], r[i]
}
return string(r)
}
reverse("Привет") // "тевирП" — верно
// побайтовый разворот []byte(s) ломает многобайтовые символы2. Задача 2: реализуйте пул воркеров на N горутин с очередью задач.
Классика конкурентного кодинга. Каркас: канал задач (обычно буферизованный), N горутин-воркеров читающих из него, sync.WaitGroup для ожидания завершения, и закрытие канала задач producer-ом — это сигнал «работы больше нет», после которого воркеры выходят из range. Типичные ошибки кандидатов: забывают wg.Done (пул висит), закрывают канал из воркера (паника), не передают канал закрытия для раннего останова. На middle-уровне ждут ещё и graceful shutdown: контекст или отдельный done-канал, чтобы пул можно было остановить, не дожидаясь конца очереди.
func pool(jobs <-chan int, workers int) []int {
results := make(chan int, workers)
var wg sync.WaitGroup
for i := 0; i < workers; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
for j := range jobs { // выход при close(jobs)
results <- j * j
}
}(i)
}
go func() { wg.Wait(); close(results) }()
var out []int
for r := range results { out = append(out, r) }
return out
}3. Задача 3: оберните вызов функции таймаутом на 2 секунды.
Базовый шаблон: результат уходит в канал, а select гонит либо результат, либо time.After. Ключевая деталь, которую проверяют этим заданием: горутина с «медленной» операцией после срабатывания таймаута НЕ останавливается — select просто перестал её ждать, а горутина живёт и держит ресурсы (это утечка). Канал результата должен быть буферизованным на 1, иначе покинутая горутина навсегда заблокируется на отправке. Взрослое решение — context.WithTimeout: операция должна сама уважать ctx.Done(), тогда таймаут реально освобождает ресурсы.
func withTimeout(fn func() int, d time.Duration) (int, error) {
ch := make(chan int, 1) // буфер обязателен!
go func() { ch <- fn() }()
select {
case v := <-ch:
return v, nil
case <-time.After(d):
return 0, errors.New("timeout")
}
}4. Задача 4: постройте пайплайн из трёх стадий (генератор → обработка → сбор).
Пайплайн — это цепочка каналов, где каждая стадия — горутина: читает из входного канала через range, преобразует, пишет в выходной, и на выходе из range (вход закрыт) закрывает свой выходной канал. Закрытие протекает по цепочке: закрыли источник — закрылась первая стадия — закрылась вторая — читатель collection-цикла завершился. Так interviewer проверяет понимание «кто владеет каналом — тот и закрывает». Ловушка: если промежуточные каналы небуферизованные, пайплайн работает в темпе самой медленной стадии — это фича (backpressure), а не баг, но о ней надо сказать словами.
func generate(nums ...int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for _, n := range nums { out <- n }
}()
return out
}
func square(in <-chan int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for n := range in { out <- n * n }
}()
return out
}5. Задача 5: реализуйте LRU-кэш с O(1) на get и put.
Стандартное решение — map для доступа по ключу плюс двусвязный список для порядка использования: map[string]*list.Element. При get элемент перемещается в голову списка (PushFront после Remove), при переполнении удаляется хвост (Back). В Go это container/list — собеседовать не ждут реализацию списка с нуля, но ждут понимания, почему map без списка не даёт порядок, а слайс вместо списка делает операции O(n). Ловушка на внимательность: list.Remove возвращает значение типа any — перед записью в map нужен type assertion. Для продвинутых: уточнить про потокобезопасность — обёртка sync.Mutex, либо озвучить sync.Map и его ограничения.
type LRU struct {
cap int
m map[string]*list.Element
l *list.List
}
type entry struct{ key, val string }
func (c *LRU) Get(k string) (string, bool) {
if el, ok := c.m[k]; ok {
c.l.MoveToFront(el)
return el.Value.(entry).val, true
}
return "", false
}
func (c *LRU) Put(k, v string) {
if el, ok := c.m[k]; ok {
el.Value = entry{k, v}
c.l.MoveToFront(el)
return
}
c.m[k] = c.l.PushFront(entry{k, v})
if c.l.Len() > c.cap {
last := c.l.Back()
delete(c.m, last.Value.(entry).key)
c.l.Remove(last)
}
}6. Задача 6: объедините результаты двух горутин в один канал (fan-in).
Fan-in — зеркальная задача к пайплайну: два потока данных собираются в один. Простое решение для двух каналов — две горутины-релея пишут в общий канал, sync.WaitGroup закрывает общий канал после обеих. Обобщение на N каналов — reflect.Select или рекурсивный merge, но на собеседовании это редко успевают: важнее назвать проблему «кто закрывает общий канал» — только после того, как закрылись все источники, иначе читатель получит неполные данные или панику. Второй момент: общий канал стоит сделать буферизованным на сумму ёмкостей источников, если нужна скорость, а не строго темповая передача.
func fanIn(a, b <-chan int) <-chan int {
out := make(chan int, cap(a)+cap(b))
var wg sync.WaitGroup
relay := func(src <-chan int) {
defer wg.Done()
for v := range src { out <- v }
}
wg.Add(2)
go relay(a)
go relay(b)
go func() { wg.Wait(); close(out) }()
return out
}7. Задача 7: напишите rate limiter — не более 3 запросов в секунду.
Простейшая версия на time.Ticker: тикер тикает 3 раза в секунду, и каждый запрос ждёт своего тика — token bucket по сути. В энтерпрайз-версии ждут либо golang.org/x/time/rate (Limiter с Wait(ctx) — рассказывает о burst и лимитах), либо собственный токен-бакет: слайс/канал токенов пополняется таймером, потребители читают non-blocking select. Проверяют два понимания: (1) rate limiter ограничивает СКОРОСТЬ, а не параллелизм — для параллелизма нужен семафор (chan struct{} ёмкостью N); (2) при остановке сервиса тикер надо остановить (ticker.Stop()), иначе утечка. Упоминание «на практике возьму x/time/rate, руками напишу только если зависимости запрещены» — правильный ответ, а не слабость.
func newLimiter(perSec int) func() {
ticks := time.NewTicker(time.Second / time.Duration(perSec))
return func() {
<-ticks.C // ждём своего тика
}
}
limiter := newLimiter(3)
for i := 0; i < 10; i++ {
limiter()
fmt.Println("запрос", i, time.Now().Format("15:04:05.000"))
}8. Задача 8: найдите первый неповторяющийся символ строки (за один проход? за два?).
Решение за два прохода: первый проход строит map[rune]int со счётчиками, второй ищет первую руну с счётчиком 1 — O(n) по времени и памяти. Обязательные уточнения, за которые дают плюс: работа с рунами, а не байтами (кириллица, эмодзи); сложность честная — map даёт O(1) в среднем, но константа заметная; для ASCII-строк вместо map эффективнее массив на 128 элементов. Если интервьюер давит «за один проход и O(1) памяти» — это либо подвох (такая задача в общем виде не решается), либо строка из ограниченного алфавита с битовой маской. Умение сказать «в общем виде нельзя, вот почему» ценится выше, чем выдумывание псевдорешения.
func firstUnique(s string) (rune, bool) {
count := make(map[rune]int)
for _, r := range s { count[r]++ }
for _, r := range s {
if count[r] == 1 { return r, true }
}
return 0, false
}9. Задача 9: остановите пул воркеров по сигналу и дождитесь завершения текущих задач (graceful shutdown).
Шаблон трёх слоёв: (1) канал остановки (context или done-канал) — воркеры проверяют ctx.Done() в select между задачами и в начале цикла; (2) WaitGroup — главный поток wg.Wait() дожидается, пока воркеры дообработают текущую задачу и выйдут; (3) producer перестаёт класть задачи при том же ctx. Проверяют именно различие: «немедленно убить» (закрыть done) и «дообработать и выйти» — не одно и то же, и смешивать их нельзя. В проде это оборачивается в http.Server.Shutdown(ctx) с таймаутом: не дождались в отведённое время — принудительный выход. Упоминание signal.NotifyContext(os.Interrupt, syscall.SIGTERM) показывает знание боевой схемы запуска и остановки сервиса.
ctx, cancel := context.WithCancel(context.Background())
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for {
select {
case <-ctx.Done():
return // стоп: текущая задача уже дообработана
case j := <-jobs:
process(j)
}
}
}()
}
// на SIGTERM: cancel(); wg.Wait()Прокачать тему в самоучителе
Читается быстро, запоминается практикой. Эти курсы закрывают тему с запуском кода прямо на странице:
- Продвинутые возможности языка Go — Продвинутый курс Go: замыкания, defer, горутины, каналы, контекст, интерфейсы, дженерики, рефлексия, тесты и JSON. 25 уроков с практикой в браузере.
- Язык Go с нуля: базовый синтаксис и конструкции — Интерактивный курс базового синтаксиса Go для начинающих: переменные, циклы, срезы, функции, структуры. 25 уроков с кодом в браузере, тестами и первым приложением.