❓ Когда использовать debug.SetGCPercent

debug.SetGCPercent используется для динамической настройки порога запуска сборщика мусора во время выполнения программы, в отличие от статической переменной GOGC.

SetGCPercent(200) снижает частоту GC, но увеличивает память.

SetGCPercent(50) запускает GC чаще с короткими паузами.

SetGCPercent(-1) полностью отключает автоматическую сборку мусоры, это эквивалентно GOGC=off, память растёт без ограничений.

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸 Библиотека Go для собеса

❓ Как sync.Pool помогает снижать давление на GC

sync.Pool снижает давление на GC, переиспользуя временные объекты между циклами сборки мусора вместо постоянных аллокаций новых.

При Get() пул возвращает готовый объект или создаёт новый через New(). После использования Put() возвращает объект в локальный пул.


🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸 Библиотека Go для собеса

❓ Что произойдёт, если у структуры есть поле-канал или функция и вы попытаетесь его cмаршалить

При попытке маршала канала в JSON возникнет ошибка:

type MyStruct struct {
    Ch chan int
}

data, err := json.Marshal(MyStruct{Ch: make(chan int)})
// error: json: unsupported type: chan int

Функции также не поддерживаются:

type MyStruct struct {
    Fn func(int) string
}

data, err := json.Marshal(MyStruct{Fn: func(i int) string { return "" }})
// error: json: unsupported type: func(int) string

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸 Библиотека Go для собеса

❓ Как вам вопросы прошедшей недели

Оцените их по шкале 🔥,❤️,👍,😢, 🥱,
где 🔥 — это супер, а 🥱 — это скучно.

Также приветствуется фидбек в комментах.

🐸 Библиотека Go для собеса

❓ Что такое Dead Letter Queue

Dead Letter Queue — это отдельная очередь для обработки сообщений, которые не могут быть успешно обработаны из основной очереди. Это механизм обработки ошибок в системах асинхронной обработки сообщений.

Как это работает

1. Сообщение попадает в основную очередь.
2. Потребитель пытается его обработать.
3. Если обработка не удаётся, то сообщение может быть переотправлено.
4. После определённого количества неудачных попыток сообщение отправляется в DLQ.
5. DLQ хранит эти мёртвые сообщения для анализа и ручной обработки.

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸 Библиотека Go для собеса

❓ Объясните, как работает директива //go:generate

//go:generate — это директива препроцессора, которая указывает инструменту go generate на необходимость выполнить определённую команду для автоматической генерации кода.

Директива должна находиться в начале файла после импортов, перед объявлениями:

package main

import "fmt"

//go:generate go run gen.go
//go:generate stringer -type=Status

type Status int

const (
    Pending Status = iota
    Active
    Done
)

func main() {
    fmt.Println("Hello")
}

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸 Библиотека Go для собеса

❓ Что такое netip.Addr и в чём его преимущества перед net.IP

netip.Addr — это тип из пакета net/netip, который представляет IP-адрес. Это современная замена net.IP.

Основные различия

Тип данных:

// net.IP - это срез байтов
type IP []byte

// netip.Addr - это структура с оптимизацией
type Addr struct {
    // Внутренняя реализация с компактным хранением
}

Размер в памяти:

import (
    "net"
    "net/netip"
)

// net.IP
var ip1 net.IP = net.ParseIP("192.168.1.1")
// Размер: от 4 до 16 байт (срез) + 24 байта (заголовок среза) = ~28-40 байт

// netip.Addr
var ip2 netip.Addr = netip.MustParseAddr("192.168.1.1")
// Размер: 16-17 байт (оптимизирован)

Преимущества netip.Addr

Его можно сравнить, а значит использовать как ключ в мапе:

// net.IP нельзя использовать как ключ в map
var m map[net.IP]string // Ошибка компиляции!

// netip.Addr можно использовать как ключ
var m map[netip.Addr]string // OK
m[netip.MustParseAddr("192.168.1.1")] = "Gateway"

Меньший расход памяти:

// net.IP - неэффективно
ips := make([]net.IP, 1000)
for i := 0; i < 1000; i++ {
    ips[i] = net.ParseIP("192.168.1.1")
}
// Высокое потребление памяти из-за срезов

// netip.Addr - эффективно
addrs := make([]netip.Addr, 1000)
for i := 0; i < 1000; i++ {
    addrs[i] = netip.MustParseAddr("192.168.1.1")
}
// Компактное хранение

Удобный API:

addr := netip.MustParseAddr("192.168.1.1")

// Методы с хорошим интерфейсом
addr.Is4()                    // true
addr.Is6()                    // false
addr.IsPrivate()              // true
addr.IsLoopback()             // false
addr.IsUnspecified()          // false
addr.IsMulticast()            // false
addr.Unmap()                  // Для IPv4-mapped IPv6
addr.String()                 // "192.168.1.1"

// Работа с префиксами
prefix := netip.MustParseAddrPrefix("192.168.1.0/24")
prefix.Contains(addr)         // true

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸 Библиотека Go для собеса

❓ Можно ли передавать канал в функцию как аргумент

Да, канал можно передавать в функцию как аргумент.

При этом можно ограничить направление канала:

// Только для отправки
func send(ch chan<- int) {
    ch <- 42
}

// Только для чтения
func receive(ch <-chan int) {
    val := <-ch
}

// Двунаправленный
func process(ch chan int) {
    ch <- 1
    val := <-ch
}

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

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸 Библиотека Go для собеса

❓ Можно ли через //go:linkname получить доступ к приватной функции стандартной библиотеки

Да, эта директива позволяет связать локальное имя с любым символом в рантайме, включая неэкспортируемые функции. Например, так можно вызвать приватную функцию runtime.nanotime:

package main

import _ "unsafe"

//go:linkname nanotime runtime.nanotime
func nanotime() int64

func main() {
    println(nanotime())
}

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

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸 Библиотека Go для собеса

❓ Какие у GOOS могут быть значения

Узнать список значений:

go tool dist list

Команда выведет все комбинации GOOS/GOARCH, которые поддерживает ваша версия Go.

Пример:

aix/ppc64
android/386
android/amd64
android/arm
android/arm64
darwin/amd64
darwin/arm64
dragonfly/amd64
freebsd/386
freebsd/amd64
freebsd/arm
freebsd/arm64
freebsd/riscv64
illumos/amd64
ios/amd64
ios/arm64
js/wasm
linux/386
linux/amd64
linux/arm
linux/arm64
linux/loong64
linux/mips
linux/mips64
linux/mips64le
linux/mipsle
linux/ppc64
linux/ppc64le
linux/riscv64
linux/s390x
netbsd/386
netbsd/amd64
netbsd/arm
netbsd/arm64
openbsd/386
openbsd/amd64
openbsd/arm
openbsd/arm64
openbsd/ppc64
openbsd/riscv64
plan9/386
plan9/amd64
plan9/arm
solaris/amd64
wasip1/wasm
windows/386
windows/amd64
windows/arm64

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса

❓ Какие виды релизов вы знаете

По стабильности:

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

• Beta — фичи готовы, но могут быть проблемы. Уже можно показывать внешним тестировщикам.

• Release Candidate — кандидат в релиз. Если критичных багов не найдут, станет финальной версией.

• Stable / General Availability — готов к продакшену.

По масштабу изменений:

• Major — ломающие изменения, несовместимость с предыдущей версией. 2.0.0 → 3.0.0.

• Minor — новая функциональность с обратной совместимостью. 2.1.0 → 2.2.0

• Patch — багфиксы без изменения API. 2.1.1 → 2.1.2

По способу деплоя:

• Canary — выкатка на небольшой процент пользователей

• Blue-green — две идентичные среды, переключение трафика между ними

• Rolling release — постепенное обновление без конкретных версий

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса

❓ Как вам вопросы прошедшей недели

Оцените их по шкале 🔥,❤️,👍,😢, 🥱,
где 🔥 — это супер, а 🥱 — это скучно.

Также приветствуется фидбек в комментах.

🐸 Библиотека Go для собеса

❓ Что такое Cache Contention

Допустим, у вас есть структура со счётчиками, которые обновляют разные горутины:

type Counters struct {
    a int64
    b int64
    c int64
}

Каждая горутина работает со своим полем. Конфликтов нет, мьютексы не нужны. Но производительность почему-то проседает.

Проблема в том, как устроен кеш процессора. CPU не читает отдельные переменные — он загружает данные кеш-линиями по 64 байта. Все три поля структуры попадают в одну линию.

Когда горутина на одном ядре изменяет поле a, процессор инвалидирует эту кеш-линию на всех остальных ядрах. Другое ядро хочет изменить b — ему приходится заново загружать линию из памяти. И так по кругу.

Это и есть Cache Contention, или false sharing — ядра конкурируют за кеш-линию, хотя работают с разными данными.

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса

❓ Как глубоко доходит отмена контекста

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

Обратного эффекта нет: отмена дочернего контекста не затрагивает родителя и других веток, только эту конкретную часть.

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса

❓ Как преобразовать int в строку и обратно

Использовать пакет strconv:

// Строка → int
num, err := strconv.Atoi("42")

// int → строка  
str := strconv.Itoa(42)

// Для других типов:
i64, _ := strconv.ParseInt("42", 10, 64)  // string → int64
str64 := strconv.FormatInt(42, 10)         // int64 → string

Atoi возвращает ошибку, если строка не число — проверяйте err

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса

❓ Как встроить профайлер в приложение

В Go есть пакет net/http/pprof, который при импорте автоматически регистрирует HTTP-обработчики для сбора метрик. Обычно профайлер запускают на отдельном порту, чтобы не смешивать с основным API.

import (
    "net/http"
    _ "net/http/pprof" // подчёркивание означает импорт ради side-effect
)

func main() {
    // Запускаем профайлер в отдельной горутине на порту 6060
    go func() {
        http.ListenAndServe(":6060", nil)
    }()
    
    // Здесь основная логика приложения...
}

После запуска становятся доступны эндпоинты для анализа:

• /debug/pprof/profile — нагрузка на процессор
• /debug/pprof/heap — использование памяти
• /debug/pprof/goroutine — состояние горутин
• /debug/pprof/block — блокировки

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса

❓ Как корректно посчитать количество символов в строке

Функция len() возвращает размер в байтах, а не в символах. Для Unicode-текста это критически важно.

Кириллица кодируется в UTF-8 двумя байтами, китайские иероглифы — тремя, а emoji, например, может занимать до четырёх байт. Поэтому для подсчёта символов нужно использовать utf8.RuneCountInString().

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса

❓ Сколько памяти занимает слайс

Заголовок слайса занимает 24 байта на 64-битной системе. Это фиксированный размер независимо от содержимого.

Внутренняя структура слайса выглядит так:

type slice struct {
    array unsafe.Pointer // 8 байт — указатель на underlying array
    len   int            // 8 байт — текущая длина
    cap   int            // 8 байт — ёмкость
}

24 байта — это только заголовок. Сами данные хранятся отдельно в массиве, на который указывает array.

Пример расчёта общего размера:

s := make([]int64, 100) 
// Заголовок: 24 байта
// Данные: 100 * 8 = 800 байт
// Итого: 824 байта

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

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса

❓ Можно ли закрыть канал со стороны читателя

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

Паника при записи в закрытый канал — это не баг, а защита от гонок данных. Отправитель точно знает, когда закончил отправлять. Читатель — не знает.

Но технически читатель закрыть канал может.

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса

❓ Как вам вопросы прошедшей недели

Оцените их по шкале 🔥,❤️,👍,😢, 🥱,
где 🔥 — это супер, а 🥱 — это скучно.

Также приветствуется фидбек в комментах.

🐸 Библиотека Go для собеса

❓ Как отправителю правильно закрыть канал

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

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

func main() {
    dataCh := make(chan int)
    stopCh := make(chan struct{})
    
    go func() {
        for {
            select {
            case data, ok := <-dataCh:
                if !ok {
                    // Канал закрыт, прекращаем обработку
                    return
                }
                // Обработка данных
                fmt.Println(data)
            case <-stopCh:
                // Получен сигнал остановки, закрываем канал dataCh
                close(dataCh)
                return
            }
        }
    }()

    // Отправка данных в канал
    dataCh <- 1
    dataCh <- 2

    // Отправка сигнала остановки
    stopCh <- struct{}{}
}

🎁 Новогодняя акция: 3 курса по цене 1
🤝 Помощь с выбором курса

🐸Библиотека Go для собеса