Что происходит, если прошел запрос на выделение памяти, но памяти не хватает?

Механизм выделения памяти в Go и обработка нехватки

В Go управление памятью осуществляется через встроенный сборщик мусора (Garbage Collector) и автоматическое выделение памяти в куче (heap). Когда программа Go запрашивает выделение памяти (например, при создании слайсов, структур, вызове new или make), происходит следующее:

Процесс выделения памяти

1. Проверка локальных кэшей — рантайм Go сначала пытается выделить память из локальных кэшей потоков (mcache), связанных с P (процессорами) в планировщике Goroutine. Это быстро и не требует глобальных блокировок.
2. Обращение к центральному кэшу — если в mcache нет подходящего блока памяти, запрос передаётся в центральный кэш (mcentral) для размера соответствующего класса.
3. Запрос к операционной системе — если в mcentral также нет свободных блоков, рантайм запрашивает новую память у ОС через системный вызов (например, mmap на Linux). Обычно запрашиваются большие регионы — спанны (spans) по несколько килобайт.

Что происходит при нехватке памяти?

Если ОС не может предоставить дополнительную память (например, из-за ограничений лимитов RSS, cgroup или исчерпания физической памяти + свопа), поведение зависит от контекста:

1. Выделение памяти в куче (heap)

При невозможности выделить новый спанн:

• Сборщик мусора (GC) запускается в попытке освободить память. Если после GC свободной памяти всё ещё недостаточно, рантайм запросит у ОС дополнительную память.
• Если ОС отказывает (например, из-за ulimit или cgroup), программа аварийно завершается с panic:

package main

import "fmt"

func main() {
    // Попытка выделить огромный слайс, который может превысить лимиты
    var hugeSlice []byte
    // Это может вызвать panic, если память исчерпана
    hugeSlice = make([]byte, 10<<30) // 10 GB
    fmt.Println("Выделено", len(hugeSlice))
}

panic: runtime: out of memory

2. Выделение памяти в стеке (stack)

• Каждая goroutine имеет свой стек, который динамически растёт (обычно с 2 КБ). Если при росте стека память недоступна, программа также завершается с panic.

3. Влияние настроек Go

Поведение можно частично контролировать:

• GOMEMLIMIT (с Go 1.19) — позволяет задать мягкий лимит памяти. При его достижении GC активируется чаще, чтобы снизить нагрузку, но не гарантирует, что лимит не будет превышен.
• GOGC — определяет агрессивность GC (по умолчанию 100%). Уменьшение значения приводит к более частому сбору мусора, что может снизить пиковое использование памяти.

// Пример: установка лимита памяти через переменную окружения
// export GOMEMLIMIT=500MiB
// Программа будет стараться не превышать этот лимит, активируя GC

Как обрабатывать такие ситуации на практике?

Проактивный мониторинг

• Используйте runtime.ReadMemStats для отслеживания использования памяти в реальном времени:

import "runtime"

func logMemStats() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    fmt.Printf("Alloc = %v MiB", m.Alloc/1024/1024)
    fmt.Printf("Sys = %v MiB", m.Sys/1024/1024)
}

Стратегии смягчения

• Оптимизация алгоритмов — избегайте неконтролируемого роста слайсов и мап, используйте пулы объектов через sync.Pool.
• Ограничение параллелизма — контролируйте количество одновременно работающих goroutine, особенно при обработке больших данных.
• Graceful degradation — при обработке запросов возвращайте ошибки 503 Service Unavailable при приближении к лимитам, а не допускайте panic.

Работа с ОС и инфраструктурой

• Устанавливайте разумные лимиты cgroup в контейнерах Docker/Kubernetes.
• Настройте мониторинг и алерты по использованию памяти (Prometheus, Grafana).
• Используйте стратегии горизонтального масштабирования при исчерпании памяти на одном узле.

Итог

В Go нехватка памяти при выделении приводит к немедленному panic и завершению программы, если рантайм не может получить дополнительную память от ОС. В отличие от языков с ручным управлением памятью (C/C++), здесь нет возможности вернуть NULL и обработать ошибку на уровне выделения. Поэтому критически важно:

1. Проектировать приложения с учётом ограничений памяти.
2. Внедрять мониторинг и лимитирование.
3. Настраивать инфраструктуру для быстрого восстановления после сбоев (например, через orchestrator).

Это делает Go менее гибким в экстремальных условиях нехватки памяти, но зато обеспечивает безопасность и простоту в типичных сценариях.