Как растет слайс?

Механизм роста слайса в Go

В Go слайс — это динамическая обертка над массивом, и его рост происходит по определенному алгоритму при добавлении элементов сверх текущей capacity (вместимости). Понимание этого механизма критично для написания эффективных программ.

Внутреннее устройство слайса

Слайс состоит из трех компонентов:

• Указатель на базовый массив
• Длина (length) — количество элементов в слайсе
• Вместимость (capacity) — размер базового массива

// Пример создания слайса
slice := make([]int, 3, 5) // length=3, capacity=5
// Указатель → [0, 0, 0, _, _]

Процесс роста при вызове append()

Когда мы добавляем элементы с помощью append() и текущая емкость недостаточна, происходит следующее:

1. Выделение нового массива большего размера
2. Копирование всех элементов из старого массива в новый
3. Добавление новых элементов в конец нового массива
4. Обновление указателя слайса на новый массив

slice := []int{1, 2, 3} // len=3, cap=3
slice = append(slice, 4) // Требуется рост!
// Происходит выделение нового массива и копирование

Алгоритм определения нового размера

Go использует умную стратегию роста, которая балансирует между производительностью и использованием памяти:

• Для маленьких слайсов (< 1024 элементов) емкость удваивается
• Для больших слайсов (≥ 1024 элементов) емкость увеличивается на 25%
• Алгоритм реализован в функции growslice в runtime Go

// Псевдокод алгоритма роста
func growslice(oldCap, newLen int) int {
    newCap := oldCap
    doubleCap := newCap + newCap
    
    if newLen > doubleCap {
        newCap = newLen
    } else {
        if oldCap < 1024 {
            newCap = doubleCap
        } else {
            for newCap < newLen {
                newCap += newCap / 4 // Увеличение на 25%
            }
        }
    }
    return newCap
}

Практические примеры роста

package main

import "fmt"

func main() {
    // Пример 1: Маленький слайс
    s1 := []int{1}
    fmt.Printf("Начальный: len=%d, cap=%d\n", len(s1), cap(s1))
    
    for i := 0; i < 10; i++ {
        s1 = append(s1, i)
        fmt.Printf("После append %d: len=%d, cap=%d\n", 
            i, len(s1), cap(s1))
    }
    
    // Пример 2: Предварительное выделение
    s2 := make([]int, 0, 100) // Оптимизация: избегаем копирований
    for i := 0; i < 100; i++ {
        s2 = append(s2, i) // Без реаллокаций!
    }
}

Критические аспекты для понимания

1. Производительность копирования

Каждый рост вызывает полное копирование всех элементов, что имеет сложность O(n). Частые реаллокации могут серьезно снизить производительность.

2. Изменение указателя

После роста слайс указывает на новый массив. Старый массив остается в памяти до сборки мусора.

slice1 := []int{1, 2, 3}
slice2 := slice1          // Оба указывают на один массив
slice1 = append(slice1, 4) // Может изменить указатель slice1
// Теперь slice1 и slice2 могут указывать на разные массивы!

3. Предварительное выделение

Лучшая практика — использовать make() с предварительным указанием capacity, если известен ожидаемый размер:

// Плохо: много реаллокаций
var badSlice []int
for i := 0; i < 1000; i++ {
    badSlice = append(badSlice, i)
}

// Хорошо: одна аллокация
goodSlice := make([]int, 0, 1000)
for i := 0; i < 1000; i++ {
    goodSlice = append(goodSlice, i)
}

Оптимизации в современных версиях Go

Начиная с Go 1.18, алгоритм роста был усовершенствован:

• Улучшено выравнивание памяти для разных типов
• Более эффективное использование кэша процессора
• Учет размера элементов при расчете нового capacity

Практические рекомендации

1. Всегда проверяйте capacity, если работаете с большими слайсами
2. Используйте make с capacity при известном размере
3. Помните о копировании — используйте copy() для явного копирования
4. Избегайте утечек памяти — усекайте слайсы с помощью slice[:len(slice):len(slice)]

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