Слабые указатели в Go: управление памятью и предотвращение утечек ресурсов

// Стандартный указатель
var strongPtr *string
// Слабый указатель
var weakPtr *sync.WeakValue

obj := "Hello, World"       // Создание объекта
strongRef := &obj           // Сильная ссылка
weakRef := sync.NewWeakValue(strongRef) // Слабая ссылка
 
// Если obj выйдет из области видимости
obj = ""                   
strongRef = nil
 
// При следующем запуске GC объект будет удалён
// weakRef.Load() вернёт nil

// Загрузка значения из слабого указателя атомарно
value := weakPtr.Load()
 
// Использование значения с проверкой на nil
if value != nil {
    // Безопасно использовать value
}

type Parent struct {
    Children []*Child
}
 
type Child struct {
    // Слабая ссылка предотвращает циклическую зависимость
    Parent *sync.WeakValue
}

obj := new(MyType)
runtime.SetFinalizer(obj, func(o *MyType) {
    // Код, выполняющийся перед сборкой объекта
    // Будьте осторожны, не создавайте здесь новых ссылок на obj!
})

// Простейшая эмуляция SoftReference на Go
type SoftCache struct {
    data map[string]*sync.WeakValue
    mu   sync.Mutex
}
 
func (c *SoftCache) Get(key string) interface{} {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    if wv, ok := c.data[key]; ok {
        if val := wv.Load(); val != nil {
            return val
        }
        // Значение было собрано GC, удаляем запись
        delete(c.data, key)
    }
    return nil
}

// Небезопасный код
if weakRef.Load() != nil {
    // Между проверкой и использованием объект может быть собран!
    doSomething(weakRef.Load())
}
 
// Безопасный код
if obj := weakRef.Load(); obj != nil {
    // obj теперь сильная ссылка, объект не будет собран до конца этого блока
    doSomething(obj)
}

type WeakQueue struct {
    items []*sync.WeakValue
    size  atomic.Int64
    mu    sync.Mutex
}
 
func (q *WeakQueue) Enqueue(item interface{}) {
    q.mu.Lock()
    defer q.mu.Unlock()
    
    q.items = append(q.items, sync.NewWeakValue(item))
    q.size.Add(1)
}
 
func (q *WeakQueue) Dequeue() interface{} {
    q.mu.Lock()
    defer q.mu.Unlock()
    
    // Очистка собранных объектов
    i := 0
    for i < len(q.items) {
        if item := q.items[i].Load(); item != nil {
            q.items = q.items[1:]
            q.size.Add(-1)
            return item
        }
        i++
    }
    
    // Если все объекты были собраны или очередь пуста
    q.items = q.items[i:]
    q.size.Store(int64(len(q.items)))
    return nil
}

type EventEmitter struct {
    listeners map[string][]*sync.WeakValue
    mu        sync.Mutex
}
 
func (e *EventEmitter) AddListener(event string, listener interface{}) {
    e.mu.Lock()
    defer e.mu.Unlock()
    
    e.listeners[event] = append(e.listeners[event], sync.NewWeakValue(listener))
}
 
func (e *EventEmitter) Emit(event string, args ...interface{}) {
    e.mu.Lock()
    defer e.mu.Unlock()
    
    // Фильтруем несобранные слушатели и вызываем их
    var alive []*sync.WeakValue
    for _, weakListener := range e.listeners[event] {
        if listener := weakListener.Load(); listener != nil {
            callback := listener.(func(...interface{}))
            callback(args...)
            alive = append(alive, weakListener)
        }
    }
    
    // Обновляем список только с живыми слушателями
    e.listeners[event] = alive
}

import "sync"
 
// Создание слабого указателя
obj := "Hello, world"
weakPtr := sync.NewWeakValue(&obj)
 
// Получение значения
if val := weakPtr.Load(); val != nil {
    str := *(val.(*string))
    fmt.Println(str) // Выведет "Hello, world"
}
 
// После сборки мусора
obj = "" // Удаляем сильную ссылку
runtime.GC() // Принудительно запускаем сборщик мусора
// Теперь weakPtr.Load() вернёт nil

type WeakMap struct {
    data map[string]*sync.WeakValue
    mu   sync.Mutex
}
 
func NewWeakMap() *WeakMap {
    return &WeakMap{
        data: make(map[string]*sync.WeakValue),
    }
}
 
func (wm *WeakMap) Set(key string, value interface{}) {
    wm.mu.Lock()
    defer wm.mu.Unlock()
    wm.data[key] = sync.NewWeakValue(value)
}
 
func (wm *WeakMap) Get(key string) (interface{}, bool) {
    wm.mu.Lock()
    defer wm.mu.Unlock()
    
    wv, ok := wm.data[key]
    if !ok {
        return nil, false
    }
    
    val := wv.Load()
    if val == nil {
        // Значение было собрано GC, удаляем запись
        delete(wm.data, key)
        return nil, false
    }
    
    return val, true
}

type WeakCache struct {
    items map[string]*sync.WeakValue
    mu    sync.RWMutex
}
 
func NewWeakCache() *WeakCache {
    return &WeakCache{
        items: make(map[string]*sync.WeakValue),
    }
}
 
func (c *WeakCache) Add(key string, value *string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.items[key] = sync.NewWeakValue(value)
}
 
func (c *WeakCache) Get(key string) (*string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    
    value, ok := c.items[key]
    if !ok {
        return nil, false
    }
    
    if val := value.Load(); val != nil {
        return val.(*string), true
    }
    
    // Элемент был собран мусорщиком
    return nil, false
}
 
func (c *WeakCache) Cleanup() {
    c.mu.Lock()
    defer c.mu.Unlock()
    
    for key, value := range c.items {
        if value.Load() == nil {
            delete(c.items, key)
        }
    }
}

type EventListener func(event string, data interface{})
 
type EventEmitter struct {
    listeners map[string][]*sync.WeakValue
    mu        sync.Mutex
}
 
func NewEventEmitter() *EventEmitter {
    return &EventEmitter{
        listeners: make(map[string][]*sync.WeakValue),
    }
}
 
func (e *EventEmitter) On(event string, listener EventListener) {
    e.mu.Lock()
    defer e.mu.Unlock()
    
    e.listeners[event] = append(e.listeners[event], sync.NewWeakValue(&listener))
}
 
func (e *EventEmitter) Emit(event string, data interface{}) {
    e.mu.Lock()
    defer e.mu.Unlock()
    
    var activeListeners []*sync.WeakValue
    
    for _, weakListener := range e.listeners[event] {
        if listenerPtr := weakListener.Load(); listenerPtr != nil {
            listener := *(listenerPtr.(*EventListener))
            listener(event, data)
            activeListeners = append(activeListeners, weakListener)
        }
    }
    
    // Обновляем список слушателей, убирая собранные
    e.listeners[event] = activeListeners
}

func ScheduleCleanup(obj *LargeObject, delay time.Duration) {
    weakObj := sync.NewWeakValue(obj)
    
    time.AfterFunc(delay, func() {
        if actualObj := weakObj.Load(); actualObj != nil {
            actualObj.(*LargeObject).Cleanup()
        }
    })
}

type TrackedObject struct {
    ID   string
    Data []byte
}
 
func NewTrackedObject(id string, size int) *TrackedObject {
    obj := &TrackedObject{
        ID:   id,
        Data: make([]byte, size),
    }
    
    log.Printf("Created object %s", id)
    
    runtime.SetFinalizer(obj, func(o *TrackedObject) {
        log.Printf("Collected object %s", o.ID)
    })
    
    return obj
}

var debugMode = false
 
func GetFromWeakCache(cache *WeakCache, key string) *MyObject {
    obj, found := cache.Get(key)
    if !found && debugMode {
        log.Printf("Cache miss for key %s - object was collected", key)
    }
    return obj
}

func StartMemoryProfiling() {
    ticker := time.NewTicker(1 * time.Minute)
    go func() {
        for range ticker.C {
            f, err := os.Create("memprofile.pprof")
            if err != nil {
                log.Fatal(err)
            }
            defer f.Close()
            
            runtime.GC() // Запускаем GC перед снятием профиля
            if err := pprof.WriteHeapProfile(f); err != nil {
                log.Fatal(err)
            }
        }
    }()
}

func TestWeakMapGarbageCollection(t *testing.T) {
    wm := NewWeakMap()
    
    // Создаём объект внутри анонимной функции,
    // чтобы он вышел из области видимости после её завершения
    func() {
        obj := &MyLargeObject{Data: make([]byte, 1024*1024)}
        wm.Set("test", obj)
        
        // Проверяем, что объект доступен
        val, found := wm.Get("test")
        if !found || val == nil {
            t.Fatal("Object should be available")
        }
    }()
    
    // Запускаем сборщик мусора несколько раз
    for i := 0; i < 5; i++ {
        runtime.GC()
    }
    
    // Теперь объект должен быть собран
    val, found := wm.Get("test")
    if found || val != nil {
        t.Fatal("Object should have been collected")
    }
}

import (
    "sync/atomic"
    "unsafe"
)
 
type UnsafeWeakPtr struct {
    ptr unsafe.Pointer // указатель на объект
}
 
func NewUnsafeWeakPtr(obj interface{}) *UnsafeWeakPtr {
    return &UnsafeWeakPtr{
        ptr: unsafe.Pointer(&obj),
    }
}
 
func (wp *UnsafeWeakPtr) Load() interface{} {
    ptr := atomic.LoadPointer(&wp.ptr)
    if ptr == nil {
        return nil
    }
    return *(*interface{})(ptr)
}

func main() {
    defer goleak.VerifyNone(t)
    
    // Код, использующий слабые указатели
    cache := NewWeakCache()
    
    // Создаём временные объекты, которые должны быть собраны
    for i := 0; i < 1000; i++ {
        obj := &HeavyObject{data: make([]byte, 1024*1024)}
        cache.Add(fmt.Sprintf("key-%d", i), obj)
    }
    
    // Запускаем сборщик мусора
    runtime.GC()
    
    // После этого не должно остаться утечек горутин
}

// Неоптимально: многократный вызов Load()
if weakRef.Load() != nil {
    process(weakRef.Load().(*MyType))
    log.Printf("Processed: %v", weakRef.Load().(*MyType))
}
 
// Оптимально: однократный вызов Load()
if obj := weakRef.Load(); obj != nil {
    typedObj := obj.(*MyType)
    process(typedObj)
    log.Printf("Processed: %v", typedObj)
}

func (wm *WeakMap) Cleanup() int {
    wm.mu.Lock()
    defer wm.mu.Unlock()
    
    count := 0
    for key, value := range wm.data {
        if value.Load() == nil {
            delete(wm.data, key)
            count++
        }
    }
    return count
}

var bufferPool = sync.Pool{
    New: func() interface{} {
        return &bytes.Buffer{} 
    },
}
 
func GetWeakBufferRef(key string, cache *WeakCache) *bytes.Buffer {
    if buf, found := cache.Get(key); found && buf != nil {
        return buf.(*bytes.Buffer)
    }
    
    // Используем пул вместо создания нового буфера
    buf := bufferPool.Get().(*bytes.Buffer)
    buf.Reset() // Очищаем буфер перед использованием
    
    // Сохраняем в кэше
    cache.Add(key, buf)
    
    return buf
}
 
func ReleaseBuffer(buf *bytes.Buffer) {
    buf.Reset()
    bufferPool.Put(buf)
}

type Canary struct {
    Value    interface{}
    Disposed chan struct{}
}
 
func NewCanary(value interface{}) *Canary {
    c := &Canary{
        Value:    value,
        Disposed: make(chan struct{}),
    }
    
    runtime.SetFinalizer(c, func(canary *Canary) {
        close(canary.Disposed)
    })
    
    return c
}
 
func WaitForDisposal(canary *Canary, timeout time.Duration) bool {
    timer := time.NewTimer(timeout)
    select {
    case <-canary.Disposed:
        timer.Stop()
        return true
    case <-timer.C:
        return false
    }
}

// Традиционная реализация с TTL
type TTLCache struct {
    data     map[string]interface{}
    expiries map[string]time.Time
    mu       sync.RWMutex
}
 
// Реализация с использованием слабых указателей
type SmartCache struct {
    data map[string]*sync.WeakValue
    mu   sync.RWMutex
}

// До: утечка памяти из-за сильных ссылок
subscriber.Subscribe("event", handler)
 
// После: подписчик может быть собран, если не используется
emitter.On("event", func(data interface{}) {
    if obj := weakSubscriber.Load(); obj != nil {
        obj.(*Subscriber).Handle(data)
    }
})

func BenchmarkStrongPointer(b *testing.B) {
    obj := &MyObject{}
    ptr := obj
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _ = ptr.Value
    }
}
 
func BenchmarkWeakPointer(b *testing.B) {
    obj := &MyObject{}
    weakPtr := sync.NewWeakValue(obj)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        if p := weakPtr.Load(); p != nil {
            _ = p.(*MyObject).Value
        }
    }
}

// Неправильно: не проверяем на nil
value := weakRef.Load().(*User)  // Может вызвать панику!
 
// Правильно: всегда проверяем результат
if ref := weakRef.Load(); ref != nil {
    value := ref.(*User)
    // Используем value...
} else {
    // Обрабатываем случай, когда объект был собран
}

type LogProcessor struct {
    // Долгоживущие данные: используем слабые указатели
    sessionConfig map[string]*sync.WeakValue
    
    // Активно изменяющиеся данные: используем обычные указатели с TTL
    activeStreams map[string]*LogStream
    streamTimers  map[string]*time.Timer
}

// Потенциальная гонка данных
if weakRef.Load() != nil {
    // Между проверкой и использованием значение может стать nil!
    doSomething(weakRef.Load())
}
 
// Безопасный код
if val := weakRef.Load(); val != nil {
    // val — это уже обычный указатель, который не изменится
    doSomething(val)
}

func RegisterAsyncHandler(event string, handler func(interface{})) {
    // Создаём слабую ссылку на обработчик
    weakHandler := sync.NewWeakValue(&handler)
    
    // Регистрируем обёртку, которая проверяет актуальность обработчика
    eventBus.Subscribe(event, func(data interface{}) {
        if h := weakHandler.Load(); h != nil {
            go (*(h.(*func(interface{}))))(data)
        }
    })
}