Что происходит в слайсе при добавлении элемента?

Механизм добавления элемента в slice Go

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

Базовый механизм append()

slice := []int{1, 2, 3}
slice = append(slice, 4)

Когда вызывается append(), происходит следующее:

1. Проверка емкости (capacity):
   • Сначала проверяется, достаточно ли места в базовом массиве слайса
   • Если len(slice) < cap(slice), элемент добавляется в существующий массив
   • Инкрементируется длина слайса (len), емкость (cap) остается прежней

// Достаточная емкость - добавление без переаллокации
slice := make([]int, 3, 5) // len=3, cap=5
slice = append(slice, 4)   // len=4, cap=5, массив не меняется

1. Переаллокация при нехватке места:
   • Если len(slice) == cap(slice), Go создает новый массив большего размера
   • Новый размер обычно удваивается (для слайсов > 1024 элементов - 1.25x)
   • Все элементы копируются в новый массив
   • Новый элемент добавляется в конец
   • Старый массив становится кандидатом на сборку мусора

// Недостаточная емкость - происходит переаллокация
slice := []int{1, 2, 3} // len=3, cap=3
slice = append(slice, 4) 
// Создается новый массив cap=6, копируются [1,2,3,4]

Детали алгоритма переаллокации

Алгоритм роста емкости реализован в runtime/slice.go:

// Упрощенное представление логики роста
func growslice(et *_type, old slice, cap int) slice {
    newcap := old.cap
    doublecap := newcap + newcap
    
    if cap > doublecap {
        newcap = cap
    } else {
        if old.len < 1024 {
            newcap = doublecap
        } else {
            // Постепенное увеличение на 25% для больших слайсов
            for newcap < cap {
                newcap += newcap / 4
            }
        }
    }
    // ... аллокация памяти и копирование
}

Практические последствия и особенности

1. Изменение базового массива:

a := []int{1, 2, 3}
b := a[:2]          // b указывает на тот же массив, что и a
b = append(b, 99)   // Меняет a[2] = 99!
fmt.Println(a)      // [1 2 99] - неожиданное изменение!

2. Утечки памяти:

func getBigSlice() []byte {
    data := make([]byte, 0, 1000000)
    // ... заполняем данные
    return data[:100] // Возвращаем только 100 элементов
    // Но базовый массив на 1МБ остается в памяти!
}

3. Предварительная аллокация для оптимизации:

// Медленно - многократные переаллокации
var slow []int
for i := 0; i < 1000; i++ {
    slow = append(slow, i)
}

// Быстро - одна аллокация
fast := make([]int, 0, 1000)
for i := 0; i < 1000; i++ {
    fast = append(fast, i)
}

4. Множественное добавление:

// append поддерживает добавление нескольких элементов
slice := []int{1, 2, 3}
slice = append(slice, 4, 5, 6)

// И добавление другого слайса (с помощью ...)
another := []int{7, 8, 9}
slice = append(slice, another...)

Производительность

Ключевые моменты для оптимизации:

• Предварительное выделение емкости через make() при известном размере
• Повторное использование слайсов через slice = slice[:0] для уменьшения аллокаций
• Мониторинг частых переаллокаций с помощью бенчмарков
• Использование sync.Pool для часто используемых слайсов большого размера

Заключение

Механизм append() в Go представляет собой компромисс между простотой использования и производительностью. Понимание его внутренней работы позволяет:

• Избегать скрытых багов при разделении базового массива
• Писать более эффективный код с контролем аллокаций памяти
• Правильно проектировать API, которое использует слайсы
• Оптимизировать критичные по производительности участки кода

Важнейший принцип: append() всегда возвращает новый слайс, даже если не произошло переаллокации. Поэтому результат append() необходимо всегда присваивать обратно в переменную слайса.