Stack allocation is suitable for small local variables with clear life cycles, and is automatically managed, with fast speed but many restrictions; heap allocation is used for data with long or uncertain life cycles, and is flexible but has a performance cost. The Go compiler automatically determines the variable allocation position through escape analysis, and if the variable may escape from the current function scope, it will be allocated to the heap. Common situations that cause escape include: returning local variable pointers, assigning values to interface types, and passing in goroutines. The escape analysis results can be viewed through -gcflags="-m". When using pointers, you should pay attention to the variable life cycle to avoid unnecessary escapes.

In Go, understanding the memory allocation mechanism of stack and heap is very important for writing efficient and safe code, especially when pointers are involved. Simply put, the stack is used to store small local variables with a clear life cycle, while the heap is used for data that requires longer survival or is of uncertain size .

Go's compiler automatically decides whether variables are allocated on the stack or on the heap, but this decision can be affected in some ways, especially when using pointers.

Stack allocation: Fast and automatic management

Stack allocation is the default behavior and applies to local variables created inside functions, especially those that will not be returned or escaped to other goroutines.

• Fast speed : Because the stack memory is continuous, allocation and release are very efficient.
• Automatic cleaning : After the function call is finished, the variables on the stack will be automatically destroyed.
• Many restrictions : You cannot pass a pointer to a stack variable to an external function or return, otherwise it will cause a dangling pointer.

For example:

 func example() *int {
    x := 10
    return &x // Warning: Return the address of the local variable, x will be transferred to the heap}

Although you are writing stack variables, the Go compiler detects "escape" behavior and automatically assigns it to the heap to avoid errors.

Heap allocation: flexible but overhead

Heap memory is managed by a garbage collector (GC) and is suitable for objects with long or uncertain life cycles.

• Manual application, automatic recycling : Objects created using new or make will be placed on the heap.
• Performance cost : Compared to stacks, heap allocation is slower and increases GC pressure.
• Applicable scenarios : Objects need to be used across functions, as return values, or have a large amount of data.

for example:

 func createValue() *int {
    x := new(int) // explicitly allocated on the heap *x = 20
    Return x
}

The returned pointer here points to the variable in the heap and will not be destroyed as the function ends.

Pointer and Escape Analysis: Key Roles of the Go Compiler

The Go compiler will perform escape analysis during the compilation stage to determine whether a variable may "escape" out of the scope of the current function. If so, it will be automatically allocated to the heap.

Common situations that cause variable escape include:

• Returns a pointer to a local variable
• Assign variables to interface types (such as interface{} )
• Pass the variable to goroutine (because concurrent access is possible)

You can view the escape analysis results through -gcflags="-m" :

 go build -gcflags="-m" main.go

The output may display information like this:

 main.go:10:5: moved to heap: x

This means that the variable x is allocated to the heap.

Practical advice: Let the compiler make decisions, but stay conscious

• Don't deliberately pursue "variables must be on the stack" unless you are optimizing hot code.
• Pay attention to the life cycle of the variable when using pointers to avoid unnecessary escapes.
• Use the escape analysis tool to see what actually happens in your code.

For example, in the following code:

 func foo() {
    s := "hello"
    fmt.Println(&s)
}

s is a local variable, but it may also be allocated to the heap because it takes its address and passes it to fmt.Println - depending on the compiler's judgment.

Overall, Go's memory allocation mechanism is smart enough to not require manual intervention in most cases. But when using pointers, understanding the difference between stack and heap and the basic principles of escape analysis can help write more efficient code. Basically that's it.

The above is the detailed content of Stack vs heap allocation with pointers in Go. For more information, please follow other related articles on the PHP Chinese website!