In Go, the runtime system decides whether to allocate memory on the stack or the heap based on the scope and lifetime of variables, using a mechanism known as escape analysis. Here's a detailed explanation of when Go allocates memory from the heap and when from the stack:
Stack Allocation
Memory is allocated on the stack when the compiler can guarantee that the memory will not be needed after the function that created it returns. This typically includes:
Local variables that do not escape the scope of the function.
Variables that are not referenced by pointers or other variables that are accessible outside the function.
Stack allocation is fast because accessing the stack is just a matter of adjusting the stack pointer. Moreover, memory on the stack is automatically reclaimed when the function exits, which simplifies memory management[1][3][7].
Heap Allocation
Memory is allocated on the heap in situations where the compiler cannot guarantee that the memory can be safely reclaimed when the function exits. This typically occurs in the following scenarios:
Dynamic Data Structures: When data structures grow dynamically (e.g., slices, maps) and their size is not known at compile time, they are allocated on the heap[1][2][5].
Escaping Variables: If a variable is referenced from outside the function where it was declared, it "escapes" to the heap. This can happen if the address of a variable is returned or stored in a globally accessible variable[1][5][6].
Large Objects: Objects that are too large to fit on the stack are allocated on the heap to avoid stack overflow. The threshold for what is considered "too large" depends on the specific implementation of the Go runti...
