“The Go programming language (Golang) supports the use of weak pointers.”

A weak pointer is a special kind of pointer that the garbage collector ignores when deciding whether an object is reachable. Go 1.24's new weak package provides weak pointers via weak.Make and weak.Pointer[T].Value().

The new experimental weak package (https://pkg.go.dev/weak) provides weak pointers: pointers that do not keep the pointer target live.

Package weak provides ways to safely reference memory weakly, that is, without preventing its reclamation. Pointer is a weak pointer to a value of type T. Objects that are only pointed to by weak pointers are not considered reachable, and once the object becomes unreachable, Pointer.Value may return nil.

Go does not provide weak references or weak pointers. There is no standard way to implement them. Proposals to add weak references have been rejected.

This proposal adds support for weak pointers to the Go language. Weak pointers are pointers that do not keep their pointees live. They become nil when their pointee is garbage collected.

Only the live objects—those reachable from a global variable or a computation in some goroutine—can affect the behavior of the program. Any time after an object becomes unreachable ("dead"), it may be safely recycled by the GC. The death of an object is not an observable event at the language level. However, Go's runtime library provides three features that break that illusion: cleanups, weak pointers, ...

The latest release of the Go language, Go 1.24, introduces several important features, including generic type aliases, weak pointers, improved cleanup finalizers, and more. Weak pointers do not increase the reference count of an object, so when an object is referenced only by weak pointers, the garbage collector can free it.

It is telling that other garbage collected languages either make "short" weak references the default and do not recommend their "long" form (C#), or only offer the "short" form to begin with (Java). The unique.Handle proposal explicitly rejected weak pointers as an alternative on the grounds that they are ...

The weak package is a package for managing weak pointers. Weak pointers are pointers that explicitly do not keep a value live and must be queried for a regular Go pointer. Using go:linkname to access this package and the functions it references is explicitly forbidden by the toolchain because the semantics of this package have not gone through the proposal process. If you believe you have a good use-case for weak references not already covered by the standard library, file a proposal issue at https://github.com/golang/go/issues instead of relying on this package.

In Go, a **weak pointer** refers to a reference that does not prevent the garbage collector (GC) from reclaiming the target object. When an object is only referenced by weak pointers and has no strong references, the GC will still treat it as unreachable and reclaim it; afterwards, all weak pointers to it will automatically become `nil`.

“Why even bother with weak pointers? Does Go even have them?” Well, yes, Go does have the weak pointer concept. It's part of the weak package, which is tied pretty closely to the Go runtime. Interestingly, it used to be more of an internal tool, but recently there's been a push to make it public through this proposal.

The `weak` package provides weak references that allow objects to be garbage collected even when referenced by cache structures, enabling memory-efficient caches and canonicalized value maps without memory leaks.

Weak pointers are a new tool in Go 1.24. They're perfect when you need to point to stuff but don't want to force it to stick around forever. Example: ptr := weak.New(value) // Create a weak grip on the value; value := ptr.(*weak.Pointer[interface{}]).Get().

A map of weak pointers to Character keeps track of the characters in the game. Method Track() adds a character to the map. GetPosition() first checks if the given character name exists in the map. Then, it attempts to turn the weak pointer from the map into a normal pointer by calling the weak pointer's Value() method.

I'm trying to create objects and insert a weak pointer to each of them in a slice. The slice then contains the only reference to each object, thus it is possible for each pointer's value to become nil anytime, and the objects' memory garbage collected. In practice, on my laptop (macOS, go 1.24.1) the weak pointers tend to become nil very fast.

Normally, weak pointers are used to break retain cycles in a system that uses references to implement garbage collection. Since Go has a tracing GC this isn't necessary. Usually, a “soft” reference, not a “weak” reference is used to implement caches. With Go, implementing a LRU+ cache using standard references is typically all that is needed.

Weak Pointers are not a new feature in Golang 1.24 because they were used internally. But now, they are officially available in Go 1.24. pointing to freed up memory but this behavior only occurs when there are no strong references anymore to the object itself so there is the differentiation between a weak pointer and a strong pointer.

In my opinion weak references should not be added to the language. If Go ever has them, they should only be implemented via a runtime API. ... When it comes to this, WeakReferences are mandatory and unfortunately Go doesn't support them :'(

The most common is if you create a reference to a field of a struct that is itself weak. The GC will gc the struct and your var can go from non-nil to nil ...