Using Weak Pointers in Go

Colin Dickson — Thu, 05 Dec 2024 13:35:24 +0000

Weak pointers are a new addition to Go (available in version 1.24+) that allow you to reference objects in memory without preventing them from being garbage collected. This blog post will introduce weak pointers, explain their usefulness, and provide a concrete example of using them to build a memory-efficient cache.

What Is a Weak Pointer?

A weak pointer is a special kind of reference to an object in memory. Unlike a strong reference, a weak pointer does not stop the garbage collector from reclaiming the referenced object if no strong references exist. This makes weak pointers an excellent tool for scenarios where you want to reference an object but don’t want to interfere with Go's automatic memory management.

In Go 1.24, weak pointers will be part of the new weak package. They work like this:

You create a weak pointer using weak.Make.
You access the referenced object (if it still exists) using the Value method.
If the garbage collector has reclaimed the object, Value returns nil.

Why Use Weak Pointers?

Weak pointers shine in cases where memory efficiency is crucial. For example:

Caches: Avoid retaining unused objects longer than necessary.
Observers: Track objects without preventing their cleanup.
References: Reduce the risk of memory leaks in long-running programs.

Example: Building a Cache with Weak Pointers

Let’s say you’re building a cache for a web server that stores frequently accessed data. You want the cache to hold data temporarily but let the garbage collector clean up objects that are no longer in use elsewhere.

Here’s how you can do that using weak pointers:

package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
    "weak"
)

// Cache represents a thread-safe cache with weak pointers.
type Cache[K comparable, V any] struct {
    mu    sync.Mutex
    items map[K]weak.Pointer[V] // Weak pointers to cached objects
}

// NewCache creates a new generic Cache instance.
func NewCache[K comparable, V any]() *Cache[K, V] {
    return &Cache[K, V]{
        items: make(map[K]weak.Pointer[V]),
    }
}

// Get retrieves an item from the cache, if it's still alive.
func (c *Cache[K, V]) Get(key K) (*V, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()

    // Retrieve the weak pointer for the given key
    ptr, exists := c.items[key]
    if !exists {
        return nil, false
    }

    // Attempt to dereference the weak pointer
    val := ptr.Value()
    if val == nil {
        // Object has been reclaimed by the garbage collector
        delete(c.items, key)
        return nil, false
    }

    return val, true
}

// Set adds an item to the cache.
func (c *Cache[K, V]) Set(key K, value V) {
    c.mu.Lock()
    defer c.mu.Unlock()

    // Create a weak pointer to the value
    c.items[key] = weak.Make(&value)
}

func main() {
    // Create a cache with string keys and string values
    cache := NewCache[string, string]()

    // Add an object to the cache
    data := "cached data"
    cache.Set("key1", data)

    // Retrieve it
    if val, ok := cache.Get("key1"); ok {
        fmt.Println("Cache hit:", *val)
    } else {
        fmt.Println("Cache miss")
    }

    // Simulate losing the strong reference
    data = ""
    runtime.GC() // Force garbage collection

    // Try to retrieve it again
    time.Sleep(1 * time.Second)
    if val, ok := cache.Get("key1"); ok {
        fmt.Println("Cache hit:", *val)
    } else {
        fmt.Println("Cache miss")
    }
}

Why This Example is Better with Weak Pointers

Without weak pointers, the cache would hold strong references to all its objects, preventing them from being garbage collected. This could lead to memory leaks, especially in a long-running server where cached objects accumulate over time.

By using weak pointers:

Memory Efficiency: Unused objects are reclaimed by the garbage collector, reducing memory usage.
Automatic Cleanup: You don’t need to implement complex eviction logic.
Thread Safety: Weak pointers integrate seamlessly into thread-safe structures like the Cache in the example.

Without weak pointers, you’d need a more manual approach, such as periodically checking and removing unused objects, which adds complexity and room for bugs.

When to Use Weak Pointers

Weak pointers are a great fit for scenarios like:

Caching temporary data.
Monitoring objects without preventing cleanup.
Tracking objects with limited lifetimes.

However, avoid using weak pointers in place of strong references when you need guaranteed access to an object. Always consider your application’s memory and performance requirements.

Conclusion

Weak pointers are a powerful tool for building memory-efficient applications in Go. This small feature can have a big impact in scenarios where managing memory efficiently is critical.