Функция runtime.KeepAlive

Функция runtime.KeepAlive предотвращает сборку мусора указанного объекта до момента вызова этой функции. Она принимает один параметр - интерфейс или указатель на объект, который нужно сохранить. Функция не возвращает никакого значения и не выполняет никаких действий, кроме как создает барьер для сборщика мусора, гарантируя, что объект останется живым хотя бы до вызова KeepAlive.

Обычно сборщик мусора может удалить объект, когда на него больше нет ссылок. Однако в некоторых случаях компилятор может оптимизировать код и удалить последнюю ссылку на объект раньше, чем это предполагает программист. Функция KeepAlive решает эту проблему, явно указывая сборщику мусора, что объект должен оставаться в памяти до определенной точки программы.

Синтаксис

runtime.KeepAlive(x)

Где x - это объект (переменная, указатель или интерфейс), который нужно сохранить от сборки мусора.

Пример с объектом в памяти

В этом примере мы создаем объект и используем runtime.KeepAlive, чтобы предотвратить его сборку до завершения функции:

package main

import (
	"fmt"
	"runtime"
)

type User struct {
	Name string
	Age  int
}

func main() {
	user := &User{Name: "Alice", Age: 30}
	// Используем объект
	fmt.Printf("User: %s, Age: %d\n", user.Name, user.Age)
	// Предотвращаем сборку мусора до этого момента
	runtime.KeepAlive(user)
	// После этой точки объект может быть собран
}

Результат выполнения кода:

"User: Alice, Age: 30"

Пример с внешним ресурсом

Рассмотрим ситуацию, когда объект содержит внешний ресурс (например, файловый дескриптор), и мы хотим гарантировать, что дескриптор не будет закрыт до завершения всех операций:

package main

import (
	"fmt"
	"os"
	"runtime"
)

type FileResource struct {
	file *os.File
	data []byte
}

func (r *FileResource) Close() {
	if r.file != nil {
		r.file.Close()
		r.file = nil
	}
}

func processFile(filename string) error {
	data, err := os.ReadFile(filename)
	if err != nil {
		return err
	}

	resource := &FileResource{
		file: nil,
		data: data,
	}
	defer resource.Close()

	// Работаем с данными
	fmt.Printf("Processing %d bytes\n", len(resource.data))

	// Предотвращаем сборку ресурса до завершения работы
	runtime.KeepAlive(resource)
	return nil
}

func main() {
	// Создаем временный файл для примера
	err := processFile("example.txt")
	if err != nil {
		fmt.Println("Error:", err)
	}
}

Пример с финализатором

Функция runtime.KeepAlive особенно полезна, когда объект имеет финализатор (установленный через runtime.SetFinalizer). Без KeepAlive объект может быть собран до того, как мы завершим работу с его данными:

package main

import (
	"fmt"
	"runtime"
	"time"
)

type Resource struct {
	id int
}

func (r *Resource) Close() {
	fmt.Printf("Resource %d is being closed\n", r.id)
}

func main() {
	r := &Resource{id: 1}

	// Устанавливаем финализатор
	runtime.SetFinalizer(r, func(obj *Resource) {
		obj.Close()
	})

	// Используем ресурс
	fmt.Printf("Using resource %d\n", r.id)

	// Предотвращаем сборку до этого момента
	runtime.KeepAlive(r)

	// Теперь объект может быть собран
	fmt.Println("Program continues...")
	time.Sleep(time.Millisecond)
	runtime.GC()
}

Результат выполнения кода:

"Using resource 1"
"Program continues..."
"Resource 1 is being closed"

Смотрите также

функцию runtime.SetFinalizer,
которая устанавливает финализатор для объекта
функцию runtime.GC,
которая запускает сборку мусора вручную
функцию runtime.GOMAXPROCS,
которая управляет количеством процессоров для выполнения горутин
тип unsafe.Pointer,
который позволяет работать с указателями низкого уровня