Réduire la pression des éboueurs à Golang

Dans les applications Go hautes performances, une allocation et une désallocation excessives de mémoire peuvent sérieusement affecter les performances, exerçant une pression inutile sur le garbage collector (GC), entraînant une latence accrue et une efficacité réduite. Cet article expliquera comment utiliser la technologie de réutilisation d'objets et la fonctionnalité sync.Pool pour réduire la pression du GC.

---

Cet article a été inspiré par un post LinkedIn de Branko Pitulic, qui soulignait l'importance d'optimiser l'utilisation de la mémoire dans les applications Go.

---

1. Comprendre les questions

Le garbage collector de Go est responsable de la gestion automatique de la mémoire. Cependant, lorsqu'une application alloue et libère de la mémoire fréquemment (en particulier sur le tas), le GC doit travailler plus fort, ce qui entraîne :

• L'utilisation du processeur a augmenté ;
• Exécution suspendue pendant le cycle GC
• Gout d'étranglement des performances dans les systèmes à faible latence.

Le but est de réduire le nombre d'objets alloués sur le tas en favorisant la réutilisation de la mémoire.

---

2. Technologie pour réduire la pression du GC

2.1 Réutilisation d'objets

Réutilisez les objets autant que possible au lieu d'en créer de nouveaux. Un modèle courant consiste à réutiliser des tranches et des tableaux.

Mauvaise pratique :

<code class="language-go">func process() []byte {
    return make([]byte, 1024) // 每次都创建一个新的切片。
}</code>

Bonnes pratiques :

<code class="language-go">var buffer = make([]byte, 1024)

func process() []byte {
    return buffer // 重用现有的切片。
}</code>

Remarque : Cette approche fonctionne bien dans des contextes non simultanés où la réutilisation est sûre.

---

2.2 Utilisation de sync.Pool

Le package

sync fournit le type Pool, qui est une structure de pool d'objets efficace qui permet la réutilisation, réduisant ainsi l'allocation de mémoire sur le tas.

Comment

sync.Pool fonctionne :

• Les objets usagés peuvent être stockés dans la piscine.
• Lorsqu'un nouvel objet est nécessaire, le pool est vérifié avant que la mémoire ne soit allouée.
• Si le pool est vide, créez un nouvel objet.

Exemple de base :

<code class="language-go">package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建一个对象池。
    pool := sync.Pool{
        New: func() any {
            return make([]byte, 1024) // 创建一个新的1KB切片。
        },
    }

    // 从池中检索一个对象。
    buffer := pool.Get().([]byte)
    fmt.Printf("Buffer length: %d\n", len(buffer))

    // 通过将对象放回池中来重用它。
    pool.Put(buffer)

    // 从池中检索另一个对象。
    reusedBuffer := pool.Get().([]byte)
    fmt.Printf("Reused buffer length: %d\n", len(reusedBuffer))
}</code>

Dans cet exemple :

1. Utilisez la fonction pour créer un New pour initialiser l'objet. sync.Pool
Utiliser pour récupérer des objets de la piscine.
2. Get Utilisez pour retourner l'objet au pool pour l'alimentation.
3. Put
<.> 3. Utilisez les meilleures pratiques de

---

sync.Pool Objets légers: Les étangs conviennent très pour les petits ou moyens. Pour les grands objets, le coût de stockage peut dépasser les revenus.

simultanément:
1. peut être utilisé en toute sécurité dans plusieurs goroutine, bien que les performances sous charge élevée puissent être différentes.
Initialisation:
2. Définissez toujours une fonction dans le pool pour assurer l'objet de création correct. sync.Pool Évitez une utilisation excessive de la piscine:
n'a utilisé que la piscine uniquement pour les objets réutilisés en temps opportun.
3. New <.> 4. Cas courants
4. <.> 4.1 Le pool de tampons pour les opérations de lecture / écriture

Les applications avec un grand nombre d'opérations de lecture / écriture (par exemple, un serveur HTTP ou un processeur de messages) peuvent réutiliser efficacement le tampon.

---

Exemple:

<.> 4.2 Utilisation du poids structurel

Si votre application crée et rejette fréquemment la structure,

peut vous aider.

Exemple:

<code class="language-go">func process() []byte {
    return make([]byte, 1024) // 每次都创建一个新的切片。
}</code>

<.> 5. Enfin les précautions

L'utilisation de peut améliorer considérablement les performances des applications, en particulier dans les scénarios à haut débit. Mais:

sync.Pool

Évitez l'optimisation prématurée. Avant d'utiliser

, utilisez des outils tels que pour analyser les performances pour vous assurer que GC est vraiment un vrai goulot d'étranglement.

L'utilisation du pool est combinée avec les meilleures pratiques générales, comme la réduction de la portée variable et l'utilisation efficace des tranches ou des tableaux.

<code class="language-go">var buffer = make([]byte, 1024)

func process() []byte {
    return buffer // 重用现有的切片。
}</code>

---

La compréhension et l'application de ces technologies vous aideront à créer des systèmes plus efficaces et évolutifs en Go.

Si vous avez des questions ou des exemples plus avancés, veuillez demander à tout moment! ?

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!