How are Go closures memory-allocated differently from other languages?

Memory Layout of Go Closures

Unlike closures in some other languages, Go closures are straightforward heap-allocated structures. They enable functions to capture and retain access to variables defined in enclosing scopes.

Consider the following Go closure:

<code class="go">type M int

func (m *M) Adder(amount int) func() {
    return func() {
        *m = *m + amount
    }
}</code>

Memory Allocation for Closures

When a closure is created, two memory allocations occur:

• Closure Structure: This structure contains a pointer to the function body and a pointer to a memory block holding the captured variables.
• Captured Variables: These variables are stored in a heap-allocated block referenced by the closure structure.

In this example, the closure captures the pointer m and an amount variable. Memory allocation for the closure would look as follows:

struct {
    F uintptr
    b [8]byte
}

[8]byte

• The first 8 bytes represent the closure structure, containing a pointer to the function body (F) and a pointer to the captured variables (b).
• The second 8 bytes hold the captured variable, amount.

Memory Footprint of Returned Function

The returned function is itself a thin wrapper that simply calls the closure structure's function pointer. It occupies a negligible amount of memory, typically just the size of a function pointer on the underlying architecture.

Additional Memory Considerations

When multiple closures share the same captured variables, they allocate the memory block only once, even if the closures are defined in different functions. This optimization reduces memory overhead.

In Go, closures promote the discipline of using the heap for long-lived values, ensuring proper memory management and garbage collection.

The above is the detailed content of How are Go closures memory-allocated differently from other languages?. For more information, please follow other related articles on the PHP Chinese website!