What is the difference between heap and stack in golang

The difference between heap and stack: 1. The heap is used to store memory segments that are dynamically allocated during process execution, while the stack is used to store local variables temporarily created by the program; 2. The life cycle ratio of heap memory Stack memory must be longer; 3. Compared with stack memory, heap memory cannot be automatically released by the compiler and can only be released by the garbage collector.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

There are two very important concepts in programming languages, heap and stack.

Heap and stack are two very important data structures, which are often used when editing programs. Go language is no exception.

Let’s take a look at these two data structures.

Stack

The stack only allows data to be put into one end of the linear table, and then the data is taken out at this end, that is, according to the first-in, last-out, Remove elements from the stack in last-in-first-out order.

The process of putting elements into the stack is called pushing. Pushing onto the stack will increase the number of elements on the stack. The last element put into the stack is at the top of the stack, and the first element put into the stack is at the bottom of the stack.

When taking an element out of the stack, it can only be taken out from the top of the stack. After taking out the element, the number of the stack will become smaller. The element put in first will always be taken out last, and the element put in last will always be taken out. First to be taken out.

Heap

The heap in memory allocation is similar to placing various furniture in a room , the size of furniture may be large or small. When allocating memory, you need to find a space large enough to hold the furniture before placing the furniture.

After repeatedly placing and vacating furniture, the space in the room will become messy. At this time, if you place furniture in this space, you will find that although there is enough space, each space is distributed in different areas. , there is no continuous space to place furniture. At this time, the memory allocator needs to adjust and optimize these spaces.

Compared with heap allocated memory and stack allocated memory, the heap is suitable for memory allocation of unpredictable sizes.

The difference between stack and heap is:

• Heap: Heap is used for storage A memory segment that is dynamically allocated during process execution. Its size is not fixed and can be dynamically expanded or reduced. When a process calls functions such as malloc to allocate memory, the newly allocated memory is dynamically added to the heap (the heap is expanded). When free and other functions are used to release memory, the released memory is removed from the heap (the heap is reduced);

  Stack: The stack is also called a stack and is used to store local variables temporarily created by the program. That is, the local variables defined in the curly braces { } of our function.

• The life cycle of heap memory is longer than that of stack memory. If the value returned by the function will be used elsewhere, then this value will be automatically allocated to the heap by the compiler.

• Compared with stack memory, heap memory cannot be automatically released by the compiler and can only be released by the garbage collector.
  

Heap and stack allocation

After the variable definition is completed, it is usually allocated on the heap and stack space Yes, which space exists depends on whether there is dynamic memory allocation (new/malloc).

For example, the following case

Case one

var p *int    //全局指针变量
func f(){
    var i int
    i = 1
    p = &i    //全局指针变量指向局部变量i
}

Case two

func f(){
    p := new(int) //局部指针变量，使用new申请的空间
    *p = 1
}

In the first case, var is used to define local variables, but due to i assignment Given the global pointer variable p, when the function ends, i will not be released at this time, so the local variable i is applied on the heap (manually released by the programmer).

• Local variable: A variable defined in a function. It has a dynamic life cycle: a new entity is created every time it is executed and survives until no one uses it (for example, there is no external pointer Point to it, there is no path to access this variable when the function exits) At this time, the space it occupies will be recycled

In the second case, use new to apply for space, because p will be lost after exiting the function will be released, so p is applied on the stack (automatically released)

[Related recommendations: Go video tutorial]

The above is the detailed content of What is the difference between heap and stack in golang. For more information, please follow other related articles on the PHP Chinese website!