À propos de Golang Make

Ce qui suit est une introduction à Golang Make à partir de la colonne tutoriel Golang J'espère que cela sera utile aux amis dans le besoin !

Golang a principalement des fonctions intégrées new et make pour allouer de la mémoire. Aujourd'hui, nous allons explorer comment jouer à make.

map ne peut allouer de la mémoire que pour la tranche, la carte, le canal et renvoyer une valeur initialisée. Tout d'abord, examinons les trois utilisations différentes suivantes de make :

1 make(map[string]string)

2 make([]int, 2)

.

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

1. La première utilisation est que la longueur du paramètre est manquante et que seul le type est transmis. Cette utilisation ne peut être utilisée que dans des scénarios. où le type est map ou chan , par exemple, make([]int) signalera une erreur. La longueur de l'espace renvoyée de cette manière est par défaut 0.

2. La deuxième utilisation spécifie la longueur. Par exemple, make([]int, 2) renvoie une tranche de longueur 2

3. longueur de la tranche.Le troisième paramètre est utilisé pour spécifier la longueur de l'espace réservé. Par exemple, a := make([]int, 2, 4). 4. Réservé ne signifie pas la longueur supplémentaire de 4, mais inclut en fait le nombre des deux premières tranches. Ainsi par exemple, lorsque vous utilisez un := make([]int, 4, 2), une erreur de syntaxe sera signalée.

Par conséquent, lorsque nous allouons de la mémoire pour une tranche, nous devons faire de notre mieux pour estimer la longueur maximale possible de la tranche, et réserver de l'espace mémoire pour la tranche en passant le troisième paramètre à faire, afin d'éviter La surcharge causée par l'allocation secondaire de mémoire améliore considérablement les performances du programme.

En fait, il nous est difficile d'estimer la longueur maximale possible de la tranche. Dans ce cas, lorsque nous appelons append pour ajouter des éléments à la tranche, golang alloue de la mémoire autant que possible pour réduire, pas. en augmentant seulement une unité d'espace mémoire à chaque fois, mais également en suivant un tel mécanisme d'expansion :

Lorsqu'il y a de l'espace réservé inutilisé, ajoutez directement des tranches à l'espace inutilisé Lorsque lorsque tout l'espace réservé est utilisé, le. l'espace étendu sera deux fois la longueur de la tranche actuelle. Par exemple, la longueur de la tranche actuelle est de 4. Après une opération d'ajout, la longueur renvoyée par cap(a) sera de 8. Jetez un œil au code de démonstration suivant :

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

Les résultats des tests ci-dessus montrent qu'après chaque extension, la longueur de l'espace mémoire doublera sa taille d'origine.

J'étais curieux et je voulais essayer. S'il continue à se développer comme ça, il se développera théoriquement de manière exponentielle. Cependant, est-ce vraiment le cas, j'ai continué à effectuer l'opération d'ajout, et le ? Le résultat suivant était le suivant :

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

Le résultat ci-dessus ignore la situation dans laquelle il n'y a pas d'expansion au milieu. On peut voir que les 11 premières extensions ont doublé la longueur à chaque fois, mais la 12ème extension ne s'est évidemment pas étendue jusqu'en 2048 comme prévu.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!