Перейти к содержимому
Учи.Онлайн Выбрать школу
Статья

Конкурентность в Go: горутины, каналы, mutex и поиск гонок данных на учебном конвейере

Конкурентность в Go — это умение разбить работу программы на независимые задачи-горутины, связать их каналами или защитить общие данные примитивами пакета sync и гарантированно остановить всё лишнее через context. Навык нужен бэкенд-разработчику, автору утилит и DevOps-инженеру, когда программа ждёт сеть, диск или базу. Осваивают его в таком порядке: горутины и каналы, select, Mutex, WaitGroup и Once, отмену через context, errgroup, поиск гонок через go test -race и утечек горутин, затем паттерны worker pool и pipeline.

Автор: редакция Учи.ОнлайнОтветственный редактор: Дмитрий Игнатьев
Содержание
Иллюстрация к статье: Конкурентность в Go: горутины, каналы, mutex и поиск гонок данных на учебном конвейере

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

Какие задачи решает конкурентность и когда она лишняя

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

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

Из каких деталей собирают конкурентный код

Канал без буфера (make(chan T)) передаёт значение из рук в руки: отправитель ждёт получателя. Буферизованный канал (make(chan T, 8)) принимает до восьми значений и блокирует отправку, только когда заполнен. Закрывает канал отправитель: чтение из закрытого канала сразу возвращает нулевое значение, цикл for v := range ch завершается, а отправка в закрытый канал и повторное закрытие вызывают панику. Оператор select ждёт несколько операций сразу; если готовы несколько, выбирается случайная.

Mutex защищает участок кода: между Lock и Unlock работает одна горутина, а повторный Lock из той же горутины даёт взаимную блокировку. WaitGroup ждёт группу горутин; с Go 1.25 у него есть метод Go, который сам увеличивает счётчик и запускает функцию. Once выполняет инициализацию ровно один раз. В документации пакета sync отдельно сказано, что Mutex и WaitGroup нельзя копировать после первого использования: структура с мьютексом, переданная по значению, защищает уже копию.

Пакет context отвечает за отмену: долгая операция принимает ctx и проверяет ctx.Done() в select. Пакет errgroup из golang.org/x/sync объединяет ожидание, сбор ошибок и отмену: по документации errgroup контекст из WithContext отменяется, как только первая функция вернёт ошибку, Wait возвращает первую ошибку, а SetLimit ограничивает число одновременно работающих горутин.

Учебный конвейер: от файла логов до отчёта

Учебная ситуация. Есть журнал склада на два миллиона строк. Каждую строку нужно разобрать, по коду товара запросить категорию у внутреннего сервиса, который отвечает за 30–50 миллисекунд, и посчитать продажи по категориям. Последовательная версия почти всё время ждёт сервис. Задача — собрать конвейер (pipeline) из трёх стадий: чтение, обработка пулом из восьми горутин (worker pool) и агрегация, причём ошибка сервиса должна остановить всю работу.

Первая стадия — единственный отправитель в канал строк, поэтому она же закрывает его через defer, а select с ctx.Done() не даёт ей зависнуть, если обработчики уже остановились из-за ошибки:

g, ctx := errgroup.WithContext(ctx)
lines := make(chan string, 64)
g.Go(func() error {
    defer close(lines)
    for sc.Scan() {
        select {
        case lines <- sc.Text():
        case <-ctx.Done():
            return ctx.Err()
        }
    }
    return sc.Err()
})

Вторая стадия — восемь горутин, которые читают lines через range, вызывают сервис с тем же ctx и пишут в канал results. Отправителей у results восемь, поэтому закрывает его отдельная горутина после того, как все обработчики завершились. Третья стадия — одна горутина, которая складывает суммы в обычную map. Мьютекс ей не нужен: карта принадлежит одной горутине.

Результат проверяют по трём признакам. Время работы падает примерно в восемь раз и дальше упирается в сервис. Тест с поддельным сервисом, который на сотой строке возвращает ошибку, показывает, что программа быстро завершается с этой ошибкой, а не висит. После Wait значение runtime.NumGoroutine() возвращается к исходному; если оно выросло, какая-то стадия осталась заблокированной на канале — горутина утекла.

Почему гонка данных опаснее неверного счётчика

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

Модель памяти Go в редакции от 6 июня 2022 года описывает последствия жёстче. Для значений не больше машинного слова чтение обязано вернуть то, что действительно было записано. Но гонка на составных структурах может дать значение, которого не записывала ни одна операция, а если оно зависит от согласованности пар «указатель и длина» или «указатель и тип», как у интерфейсов, карт, срезов и строк в большинстве реализаций Go, такая гонка способна привести к произвольному повреждению памяти. Срез, который одна горутина заменяет, а другая читает, может прочитаться с длиной от нового и указателем от старого: программа упадёт в чужом месте или молча испортит данные.

Тот же документ объясняет полезную идиому: получение k-го значения из канала ёмкостью C синхронизировано до завершения отправки (k+C)-го, поэтому буферизованный канал работает как счётный семафор. Отправка занимает место, получение освобождает, ёмкость задаёт предел одновременных запросов к сервису.

Детектор гонок включают флагом -race в go test, go run и go build. Он сообщает только о гонках, которые случились во время запуска, поэтому тест должен гонять конвейер на сотнях строк из нескольких горутин. Запуск go test -race ./... в CI стоит включить с первого конкурентного проекта.

В каком порядке осваивать и как тренироваться

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

  1. Горутины и WaitGroup: запустить десять задач и дождаться всех.
  2. Каналы с буфером и без, закрытие, range, select с таймаутом.
  3. Mutex и Once; та же задача с общей картой под мьютексом и с одной горутиной-владельцем.
  4. context и errgroup: отмена по первой ошибке и по таймауту.
  5. Детектор гонок и проверка утечек на каждом упражнении.
  6. Worker pool, pipeline и семафор на буферизованном канале.

Хорошие упражнения небольшие и проверяемые: скачать список адресов не более чем по пять одновременно; написать конвейер «чтение — обработка — запись», который останавливается по Ctrl+C; намеренно оставить гонку, увидеть отчёт детектора и исправить её двумя способами. Типичные ошибки — закрыть канал со стороны получателя, вызвать wg.Add(1) внутри горутины, забыть ветку ctx.Done() или сделать сетевой вызов под мьютексом.

Если упражнения идут, а не хватает структуры и проверки кода, ищите программу, где конкурентность связана с реальным сервисом. На курсе Eduson Academy «GO-разработчик» в программе названы асинхронная модель, конкурентность, работа с памятью и профилирование, а выпускная работа — приложение с базой данных, синхронизацией и модульными тестами с покрытием от 50 %. Горутины, каналы и мьютексы в описании отдельно не перечислены, глубину блока уточните у школы.

Открыть курс «GO-разработчик: тариф Базовый»

Как выбрать обучение под конкурентный код

Название модуля «Конкурентность» мало что говорит. Спросите школу, разбирают ли на курсе закрытие каналов при нескольких отправителях, context, errgroup, детектор гонок и утечки горутин и есть ли задание, где проверяют именно остановку программы.

Тем, кто переходит на Go с другого бэкенд-языка, подходит курс Слёрма «Разработчик на языке программирования Go»: 13 тем, видеоуроки и около 50 часов практики, в первой половине — конкурентная обработка данных, тесты и context, во второй — сервис с gRPC и трейсинг. Школа ждёт понимания баз данных и очередей, а проверка заданий есть только в командном тарифе.

Открыть курс

Если Go для вас первый язык, конкурентность придёт после основ, и важно, чтобы программа не обрывалась на синтаксисе.

Бюджетный вариант — комплект Merion Academy «Go-программист с нуля» и «DevOps-инженер с нуля»: два асинхронных курса примерно по четыре месяца с бессрочным доступом. Горутины и каналы названы в программе одной строкой, о мьютексах, context и детекторе гонок в описании ничего нет, проверка кода преподавателем не заявлена — эти темы придётся закрывать самостоятельными упражнениями.

Открыть курсы по Go и DevOps

Как навык влияет на доход

Отдельной надбавки за конкурентность в открытых зарплатных данных нет: в вакансиях Go-разработчика горутины, каналы и context входят в базовый набор. Навык влияет на доход косвенно — открывает задачи нагруженных сервисов: обработку очередей, параллельные запросы к внешним системам, корректную остановку при выкладке. На собеседованиях его проверяют задачами: найти взаимную блокировку, объяснить, кто закрывает канал, ограничить параллельность обработчика.

Сравнить онлайн-школы по цене и формату можно в рейтинге онлайн-школ с обучением Go — он охватывает язык целиком, а не только конкурентность. Актуальные зарплаты смотрите в отчётах «Хабр Карьеры» и в вакансиях с фильтром по опыту.

Общая картина языка разобрана в статье о Go, профессия — в статье о Go-разработчике. Если учебный конвейер у вас останавливается по первой ошибке, проходит go test -race и не оставляет висящих горутин, база для следующего шага уже есть.