В какой структуре в runtime лежит слайс

Внутреннее представление слайса в Go runtime

В Go слайс (slice) является абстракцией над массивом, предоставляющей динамический и гибкий интерфейс для работы с последовательностями данных. В runtime слайс представлен структурой, состоящей из трёх компонентов:

// runtime/slice.go
type slice struct {
    array unsafe.Pointer // Указатель на базовый массив
    len   int            // Текущая длина слайса
    cap   int            // Ёмкость (максимальная длина без реаллокации)
}

Детальное описание полей структуры

array (указатель на базовый массив):

• Это указатель на первый элемент базового массива в памяти
• Тип unsafe.Pointer позволяет работать с памятью напрямую, без проверок типов
• Указывает на начало сегмента массива, который принадлежит слайсу
• При срезе (slicing) создаётся новый слайс с тем же указателем, но смещённым

len (длина):

• Количество элементов, которые currently содержит слайс
• Определяет границу для индексации: slice[0:len-1]
• При обращении к индексу >= len происходит паника с выходом за границы
• Функция len() возвращает именно это значение

cap (ёмкость):

• Максимальное количество элементов, которое может содержать слайс без перевыделения памяти
• Определяет, до какого предела может расти слайс с помощью append()
• Всегда cap >= len
• Функция cap() возвращает это значение

Пример создания и внутренней структуры

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // Создаём слайс с начальными значениями
    slice := []int{10, 20, 30, 40, 50}
    
    // Доступ к внутренним полям через unsafe
    sliceHeader := (*[3]int)(unsafe.Pointer(&slice))
    
    fmt.Printf("Указатель на массив: %p\n", unsafe.Pointer(sliceHeader[0]))
    fmt.Printf("Длина (len): %d\n", sliceHeader[1])
    fmt.Printf("Ёмкость (cap): %d\n", sliceHeader[2])
    fmt.Printf("Размер структуры слайса: %d байт\n", unsafe.Sizeof(slice))
}

Ключевые особенности внутреннего представления

Семантика значений:

• Сама структура слайса (3 слова) передаётся по значению
• При передаче в функцию копируются только указатель, len и cap
• Несколько слайсов могут указывать на одни и те же данные массива

func modifySlice(s []int) {
    s[0] = 100  // Изменяет базовый массив
    s = append(s, 999)  // Может создать новый массив
}

func main() {
    original := []int{1, 2, 3}
    modifySlice(original)
    fmt.Println(original) // [100, 2, 3]
}

Операции и их влияние на структуру:

• Создание через make():

  s := make([]int, 5, 10)
  // Создаёт массив размером 10, len=5, cap=10
  

• Срезы (slicing):

  base := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
  slice := base[2:5]  // len=3, cap=8 (10-2)
  // array указывает на base[2], len=3, cap рассчитывается от исходного массива
  

• Функция append():

  • Если len < cap, добавляет элемент в существующий массив
  • Если len == cap, создаёт новый массив (обычно удваивая capacity), копирует данные и обновляет указатель

Оптимизации в runtime

Go runtime включает несколько оптимизаций для работы со слайсами:

1. Быстрое выделение памяти для малых слайсов через кэшированные массивы
2. Алгоритм роста capacity: для маленьких слайсов удваивание, для больших — рост на 25%
3. Escape analysis для определения, может ли слайс быть размещён на стеке
4. Специальные функции в runtime для копирования, сравнения и манипуляций со слайсами

// Пример оптимизации: копирование слайсов
src := []byte("hello")
dst := make([]byte, len(src))
copy(dst, src)  // Вызывает runtime.memmove для эффективного копирования

Практические следствия понимания внутренней структуры

1. Эффективность памяти: слайс занимает 24 байта на 64-битной системе (8 + 8 + 8)
2. Производительность: операции в пределах capacity не требуют выделения памяти
3. Совместное использование данных: несколько слайсов могут разделять один массив
4. Утечки памяти: удерживание ссылки на маленький срез большого массива препятствует GC

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

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