About golang make

The following column golang tutorial will introduce you to golang’s make. I hope it will be helpful to friends in need!

Golang allocates memory mainly through the built-in functions new and make. Today we will explore how make can be played.

map can only allocate memory for slice, map, and channel, and return an initialized value. First, let’s take a look at the following three different uses of make:

1. make(map[string]string)

2. make([]int, 2)

3. make([]int, 2, 4)

1. The first usage is that the parameter is missing the length and only the type is passed. This usage can only be used in scenarios where the type is map or chan. , for example, make([]int) will report an error. The space length returned in this way defaults to 0.

2. The second usage specifies the length. For example, make([]int, 2) returns a slice with a length of 2

3. The third usage, the second The parameter specifies the length of the slice. The third parameter is used to specify the length of reserved space. For example, a := make([]int, 2, 4). It is worth noting here that the total length of the returned slice a is 4. Reserved does not mean the extra length of 4, but actually includes the number of the first two slices. So for example, when you use a := make([]int, 4, 2), a syntax error will be reported.

Therefore, when we allocate memory for a slice, we should try our best to estimate the possible maximum length of the slice, and reserve memory space for the slice by passing the third parameter to make, so as to avoid The overhead caused by secondary allocation of memory greatly improves the performance of the program.

In fact, it is difficult for us to estimate the possible maximum length of the slice. In this case, when we call append to append elements to the slice, golang in order to reduce the secondary allocation of memory as much as possible , not only increasing one unit of memory space each time, but also following such an expansion mechanism:

When there is reserved unused space, the unused space is directly added to the slice. When all the reserved space is used up, the expanded space will be twice the length of the current slice. For example, the length of the current slice is 4. After an append operation, the length returned by cap(a) will be 8. Take a look at the following demo code:

package main

import (        "fmt")

func main() {
        a :=  make([]int, 0)
        n := 20
        for i := 0; i < n; i++ {
                a = append(a, 1)
                fmt.Printf("len=%d cap=%d\n", len(a), cap(a))
        }
}

Output:
len=1 cap=1  // 第一次扩容len=2 cap=2 // 第二次扩容len=3 cap=4 // 第三次扩容len=4 cap=4len=5 cap=8 // 第四次扩容len=6 cap=8len=7 cap=8len=8 cap=8len=9 cap=16 // 第五次扩容len=10 cap=16len=11 cap=16len=12 cap=16len=13 cap=16len=14 cap=16len=15 cap=16len=16 cap=16len=17 cap=32 // 第六次扩容len=18 cap=32len=19 cap=32len=20 cap=32

The above test results show that after each expansion, the memory space length will double its original size.

I am curious and want to try it. If it continues to expand like this, it will theoretically expand exponentially. However, will this really be the case? I continue to perform the append operation, and the subsequent output is like this:

0 0
1 1
2 2
4 4
8 8
16 16
32 32
64 64
128 128
256 256
512 512
1024 1024
1312 1312    // 288
1696 1696    // 384
2208 2208    // 512
3072 3072    // 864
4096 4096    // 1024
5120 5120    // 1024
7168 7168    // 2048
9216 9216    // 2048

The above output ignores the situation where there is no expansion in the middle. It can be seen that the first 11 expansions did double the length each time, but the 12th expansion obviously did not expand to 2048 as expected.

The above is the detailed content of About golang make. For more information, please follow other related articles on the PHP Chinese website!