golang

Рецензия на книгу «Высокопроизводительный Go. Руководство по оптимизации» — от sync.Pool до QUIC и …

  • четверг, 19 ноября 2026 г. в 00:00:13
https://habr.com/ru/companies/ssp-soft/articles/1108260/

Разбираем книгу Александра Ставонина «Высокопроизводительный Go. Руководство по оптимизации» (АЛИСТ, 2026, 256 страниц). Используя мониторинг, автор показывает, как снизить нагрузку на сборщик мусора (Garbage Collector, GC), укротить горутины (легковесные потоки) и собрать сетевой сервис, который держит десятки тысяч соединений. Студентам, стажерам и начинающим разработчикам (джунам) книга даст полезные знания для улучшения производительности приложений. А еще в книге есть ответы на вопросы, которые часто задают на собеседованиях по Go.

Краткий анонс этой книги издательство БХВ уже опубликовало в своем блоге на Хабре («Новинка “Высокопроизводительный Go. Руководство по оптимизации”»). Ниже мы даем подробный разбор всех 29 глав с цифрами из сравнительных тестов (бенчмарков) и советами о том, какие главы читать для технических собеседований. 

Книгу можно приобрести на сайте издательства. Напомним, что на все бумажные книги по компьютерным технологиям от издательств «БХВ-Петербург», «Alist» и «Фолиант» доступен промокод SSPSOFT на скидку 25% как подарок читателям Хабра от нашего блога.

Про автора и истоки рождения книги

Александр Ставонин специализируется на Go, C++, интернете вещей и высокопроизводительных вычислениях. Первые версии материалов автор выкладывал на сайте goperf.dev, а затем переработал их в книжный формат. Издание вышло в Астане в 2026 году. 

Книга состоит из двух частей.

  • Первая (главы 1–15) описывает универсальные приемы оптимизации памяти, параллельных вычислений, ввода-вывода и сборки.

  • Вторая часть (главы 16–29) целиком посвящена настройке сетевых сервисов.

Сама идея книги вполне умещается в одну фразу из введения. Автор предлагает сразу начать писать оптимальный код, который выдержит нагрузку, и проверять каждый прием бенчмарком. Go не дает такого тонкого контроля, как C++ или Rust, и автор это отдельно отмечает, поэтому книга имеет практическую направленность.

Для какой аудитории эта книга

Автор адресует книгу бэкэнд-инженерам, которые строят сервисы с жесткими требованиями к задержкам и пропускной способности соединения, а также командам, переписывающим критичные части системы с другого языка на Go. С нашей точки зрения круг читателей такой:

  • студенты и стажеры, которые уже написали на Go несколько программ и хотят понять, что происходит с памятью, сборщиком мусора и планировщиком;

  • начинающие разработчики в бэкэнде, которым на собеседовании задают вопросы про sync.Pool, анализ побегов (escape analysis), контекст и ограничение числа горутин;

  • опытные разработчики с опытом 3-6 лет (мидлы), отвечающие за API-шлюзы, чаты, потоковые сервисы и другие нагруженные системы;

  • программисты, переходящие на Go с Java, C# или C++ и сравнивающие устройство сборщиков мусора;

  • руководители групп (тимлиды), которым нужны показатели для оценки кода (код-ревью) и его оптимизации.

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

Обзор глав

Почти каждая глава в книге построена по одинаковой схеме. Сначала автор объясняет механизм, затем приводит примеры кода «до» и «после», за которыми следуют результаты сравнительного теста (бенчмарка) и завершается глава разделом «Когда следует использовать».

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

Часть 1. Главы 1 - 15.

Главы 1–4. Память, пулы, выравнивание и интерфейсы

Первая глава учит повторно использовать объекты через механизм sync.Pool. В бенчмарке книги прямое выделение большой структуры занимает 705,4 нс с одним выделением на 8192 байта, а версия с пулом укладывается в 7,455 нс без единого выделения. Разница примерно в 95 раз, и автор сразу предупреждает, что при низком коэффициенте повторного использования пул приносит только лишнюю сложность.

Во второй главе разбирается предварительное выделение срезов и карт через механизм make с заданной емкостью. Автор объясняет стратегию роста среза (удвоение до 1024 элементов, затем примерно на 25%) и показывает, как это сокращает 19 выделений до одного. 

Третья глава посвящена выравниванию полей структур. Структура на 24 байта превращается в структуру на 16 байт простой перестановкой полей, а на 10 миллионах экземпляров экономия составляет 80 Мбайт. Здесь же рассказано про ложное совместное использование кэш-линий (false sharing) в многопоточном коде и про статический анализатор выравнивания. 

Четвертая глава объясняет упаковку значений в интерфейс, из-за которой срез интерфейсов незаметно порождает тысячи выделений, и учит искать такие места по вызову runtime.convT в профиле.

Главы 5–7. Нулевое копирование, сборщик мусора и стек

Пятая глава показывает, как работать без лишних копий. Автор использует io.Reader и io.Writer, нарезку срезов вместо копирования и отображение файла в память (mmap), а в конце приводит библиотеки, где эти приемы применены, например Protobuf, MsgPack и Badger. 

Шестая глава объясняет, как устроен сборщик мусора Go. Он не делит объекты на поколения, работает параллельно с программой по схеме трехцветной разметки, а паузы остановки (Stop-The-World) обычно не превышают 100 микросекунд. Для настройки автор разбирает GOGC и GOMEMLIMIT, а также новый пакет weak для слабых ссылок из Go 1.24. Седьмая глава показывает, как удерживать значения на стеке и когда это не стоит делать из-за потери читаемости.

Главы 8–12. Горутины, синхронизация и контекст

Восьмая глава сравнивает неограниченный запуск горутин с пулом рабочих горутин. В бенчмарке пул выигрывает по времени (1,79 мс против 2,50 мс на операцию) и вдвое экономит память (около 321 Кбайт против 639 Кбайт). Автор отдельно показывает, что число рабочих выше количества ядер процессора ухудшает результат. 

Девятая глава сопоставляет атомарные операции и взаимное исключение (мьютексы), сравнивает модель памяти Go с моделью C++ и советует брать атомарные операции только для простых случаев. В десятой главе разбирается “ленивая инициализация” через sync.Once, sync.OnceValue и sync.OnceValues. 

Одиннадцатая глава описывает обмен неизменяемыми данными. Конфигурация или таблица маршрутизации собирается заново и подменяется атомарно. Автор подсказывает, что синтетические бенчмарки здесь вводят в заблуждение, и рекомендует проводить измерения на реальной системе. 

Двенадцатая глава посвящена контексту. В ней рассмотрены отмена запроса, тайм-ауты базы данных, передача идентификаторов трассировки, плавное завершение работы утилит командной строки и правило не хранить бизнес-данные в контексте.

Главы 13–15. Ввод-вывод, пакеты операций и флаги сборки

Тринадцатая глава о буферизации дает наглядные цифры по производительности Go. Запись небуферизованным способом занимает 23,67 мс на операцию, через bufio.Writer (буфер по умолчанию 4 Кбайт) всего 0,38 мс, то есть примерно в 62 раза быстрее. 

Четырнадцатая глава показывает пакетную обработку. Для файлового ввода-вывода выигрыш составил почти 13 раз (12,77 мс против 0,99 мс, число выделений упало с 10 007 до 207), для хеширования около 1,8 раза, а для простой работы со строками в памяти разница оказалась скромной. Автор добавляет, что пакетная обработка это лишь один из приемов и в разных случаях прирост производительности может отличаться кардинально. 

Пятнадцатая глава разбирает флаги -gcflags и -ldflags, теги сборки, кросс-компиляцию и статические бинарные файлы. Удаление отладочной информации, по словам автора, уменьшает размер бинарного файла на 30–40%, что заметно облегчает образы Docker.

Часть 2. Главы 16-29

Главы 16–17. Нагрузочное тестирование и профилирование

Вторая часть начинается с методики. Автор в главе 16 сравнивает vegeta, wrk и k6, объясняет, как снимать профиль процессора и памяти через pprof, как читать граф пламени (flame graph) и как встроить бенчмарки в цикл разработки. 

Глава 17 разбирает учебное приложение с конечными точками /fast и /slow и тяжелым по памяти обработчиком /gc. Читатель видит, как в профиле почти 20% процессорного времени уходит на выделение памяти и сборку мусора, а 99,46% мусора размером 649 Мбайт принадлежит одной функции. На таком примере хорошо учиться читать pprof.

Главы 18–21. Внутреннее устройство сети Go и масштабирование

Глава 18 объясняет, как горутины, планировщик и сетевой опрос (netpoller) через epoll, kqueue и IOCP превращают блокирующий ввод-вывод в событийный. Глава 19 переходит к практике и перечисляет настройки net/http и net.Conn для высокой нагрузки, например MaxConnsPerHost, размеры буферов сервера и собственные преобразователи DNS. 

Глава 20 строит TCP-сервер на 10 000 одновременных соединений и измеряет его на экземпляре AWS c5.2xlarge с помощью tcpkali. После настройки буферизованной записи объем принятых данных за минутный прогон вырос с 210 до 1661 Мбайт. Автор трезво замечает, что на практике цель «100 тысяч соединений» упирается в ulimit, эфемерные порты и стек TCP, и начинать лучше с 10–20 тысяч стабильных соединений. Глава 21 посвящена GOMAXPROCS, трассировке планировщика через GODEBUG и закреплению потоков, причем автор сам предупреждает, что в большинстве приложений выигрыш от такой настройки минимален.

Главы 22–23. Устойчивость и утечки в долгоживущих соединениях

Глава 22 собирает защитные шаблоны. Это предохранители (circuit breaker), пассивный и активный сброс нагрузки (load shedding), контроль потока через буферизованные каналы, тайм-ауты и плавная деградация функциональности. Автор сравнивает тайм-ауты 50 и 200 мс и объясняет, как короткие защищают систему, а длинные повышают пропускную способность.

Глава 23 перечисляет типичные утечки в WebSocket и TCP-потоках. К ним относятся горутины, которые никто не остановил, растущие очереди каналов и малый срез, удерживающий исходный буфер на 4 Кбайт. Лечение сводится к срокам чтения и записи, ограниченным очередям и явной очистке.

Главы 24–25. Выбор протокола

Глава 24 сравнивает три варианта для связи сервисов. Это сырой TCP с собственным кадрированием по префиксу длины, HTTP/2 через net/http (в Go он включается автоматически с версии 1.6) и gRPC.  

Глава 25 вводит транспортный протокол QUIC и библиотеку quic-go. Читатель узнает про независимые потоки без блокировки начала очереди (head-of-line blocking), шифрование через TLS 1.3, возобновление соединения без дополнительного оборота (0-RTT) и перенос соединения между сетями.

Главы 26–29. Сокеты, DNS, TLS и наблюдаемость

Глава 26 учит настраивать сокеты. Разобраны отключение алгоритма Нагла через TCP_NODELAY, SO_REUSEPORT, размеры буферов SO_RCVBUF и SO_SNDBUF, TCP Keepalive и SOMAXCONN. Глава 27 сравнивает встроенный и cgo-резолвер DNS, говорит о кэшировании и о подмене звонилки (dialer) с заранее разрешенными адресами. 

Глава 28 ускоряет TLS через возобновление сеанса, выбор наборов шифров, согласование протокола прикладного уровня (ALPN) и экономию на проверке сертификатов. Глава 29 замыкает книгу темой наблюдаемости. Автор предлагает измерять каждый этап жизни соединения (DNS, установка, рукопожатие, чтение и запись, закрытие) и выставлять их как отдельные метрики вроде connection_dns_duration_seconds.

Как читать книгу джунам и стажерам

Новичкам в Go рекомендуется начать чтение с глав 1–4 и 6–8. Там меньше всего теории и больше всего тем, о которых спрашивают на собеседованиях. После них вы сможете ответить своими словами на такие вопросы:

  • когда sync.Pool помогает, а когда только усложняет код;

  • что такое анализ побегов и как посмотреть его результат через флаги компилятора;

  • зачем заранее выделять срезы и карты и как растет срез;

  • чем GOGC отличается от GOMEMLIMIT и что делают паузы остановки мира;

  • как ограничить число горутин и корректно отменить работу через контекст;

  • чем сырой TCP, HTTP/2 и gRPC различаются по цене для сервиса.

Читать книгу надо, сочетая теорию с практикой. Возьмите любой небольшой HTTP-сервис, прогоните его через vegeta или k6, снимите профиль через pprof и примените два-три приема из первой части. Затем повторите бенчмарк и сравните цифры. Все цифры в книге получены на компьютерах автора (ноутбук с M3 Max и экземпляр AWS), на вашем железе они будут другими.

После этой книги логично читать документацию по GC («A Guide to the Go Garbage Collector»), заметки к релизам Go и разборы профилей реальных сервисов. Это закрепит материал.

Заключение

Главная ценность книги Александра Ставонина в том, что каждый прием проверен тестами и снабжен границами применимости. Читатель видит, где пул объектов дает выигрыш в десятки раз, где буферизация ускоряет запись на два порядка, а где результат окажется скромным или отрицательным. Вторая часть дает редкий для русскоязычной литературы разбор сетевого стека Go от планировщика и сетевого опроса до TLS, DNS и QUIC, а завершается главой о наблюдаемости соединений, которую можно сразу применять в рабочих сервисах.

Вторая сильная сторона книги - в примерах из продуктовой среды. Автор говорит о нагрузках, на которые натыкаются инженеры в корпоративном окружении, о десятках тысяч соединений, утечках в долгоживущих сессиях, сбросе нагрузки и выборе протокола. Для студентов, стажеров и джунов это один из самых полезных русскоязычных источников для профессионального роста - перейти от «я пишу на Go» к «я понимаю, как Go ведет себя под большой нагрузкой». 

Немного о SSP SOFT как компании — у нас почти всегда есть вакансии, мы 19 лет занимаемся заказной разработкой ПО и ИТ‑аутсорсингом (входим в Топ-50 ИТ‑компаний России по рейтингу RAEX). Ждем резюме специалистов, готовых работать оффлайн в Москве (ЦАО) или в Томске, а также удаленно из любой точки России. Подробности о вакансиях читайте на странице ХХ.ру и направляйте отклики напрямую в ЛС руководителю службы найма в ТГ (можно и на почту job@ssp‑soft.com). Не забудьте добавить «секретную фразу» в сопроводительное письмо: «Увидел(а) вашу вакансию на Хабре».

Успехов в освоении секретов языка Go!

Нам будет приятно, если заглянете в наш телеграм‑канал SSP SOFT. Там мы публикуем разные полезности из мира ИТ, советы для поддержания здоровья и продуктивности, проводим конкурсы с призами.