La collection GO Garbage (GC) est automatique, en utilisant un algorithme d'élimination de marque en trois couleurs simultanés, implémente la collection simultanée via une barrière d'écriture, optimise le recyclage des objets cyclables courtes et maintient un faible temps de pause. Les développeurs peuvent améliorer les performances grace à la réutilisation des objets et évite les fuites de mémoire. 1. GC marque les objets accessibles de l'objet racine et efface les objets inaccessibles. 2. Les barrières d'écriture garantissent que les mises à jour de référence ne sont pas manquées pendant la concurrence. 3. Bien qu'il n'y ait pas de division générationnelle explicite, elle est optimisée selon "la plupart des objets meurent prématurément" et le GC à cycle court est fréquemment exécuté. 4. seules des pauses submillisines sont générées au début et à la fin de la marque pour assurer une faible latence. 5. Les développeurs peuvent utiliser Sync.Pool pour réutiliser des objets pour réduire la pression d'allocation et éviter les problèmes de mémoire causés par la maintien à long terme de grands objets ou des références globales. GO'S GC fonctionne efficacement en arrière-plan, équilibrant la mémoire et les frais généraux du processeur, et convient aux applications modernes.

La collecte des ordures (GC) dans GO est automatique et con?ue pour simplifier la gestion de la mémoire pour les développeurs. Contrairement aux langues comme C ou C, où vous allouez manuellement et la mémoire libre, GO gère cela pour vous en récupérant la mémoire qui n'est plus utilisée. Voici comment cela fonctionne dans un sens pratique et réel.

1 .

Go utilise un collecteur de déchets mark-et-sweep simultanée . Cela signifie qu'il retrace la mémoire de votre programme, à partir d'objets "racine" (comme les variables globales et les variables de pile), et marque tout ce qui est encore accessible. Tout ce qui n'est pas marqué est considéré comme des ordures et est nettoyé.

Le processus a deux phases principales:

• MARQUE PHASE : Le GC traverse tous les objets accessibles et les marque ?en usage?.
• Phase de balayage : il passe par des régions de mémoire non marquées et les récupére pour les allocations futures.

Parce que c'est simultanément , le collecteur des ordures fonctionne à c?té de votre programme (le "mutateur"), minimisant les pauses. C'est un gros problème pour les applications à faible latence.

2. Les barrières d'écriture permettent une collection simultanée

Une clé pour rendre GC simultanément est l'utilisation de barrières d'écriture . Lorsque votre programme met à jour un pointeur (par exemple, obj.field = newObj ), un petit morceau de code (la barrière d'écriture) s'exécute en premier pour informer le GC sur le changement.

Cela garantit que le GC ne manque pas les références créées pendant sa course. Sans barrières d'écriture, le GC pourrait percevoir à tort un objet qui vient d'être référencé. Ils ajoutent une minuscule surcharge mais permettent au programme de continuer à fonctionner sans s'arrêter pour de longues pauses GC.

3. Hypothèses générales (non explicites, mais optimisées)

Go n'a pas de GC générationnel traditionnel comme Java (avec des générations jeunes / vieilles), mais il est optimisé autour de la même idée: la plupart des objets meurent jeunes .

Le GO GC se concentre sur l'efficacité par:

• Prioriser l'allocation rapide (à l'aide d'un allocateur de bosse dans les caches thread-local).
• En fonctionnant fréquemment, de courts cycles GC pour nettoyer rapidement les objets de courte durée.
• Réglage de la fréquence GC basée sur la croissance du tas (contr?lé via GOGC ).

GOGC=100 signifie que GC s'exécute lorsque la mémoire du tas double. Vous pouvez ajuster cela pour échanger la mémoire contre l'utilisation du processeur.

4. Temps de pause faible via la concurrence

Modern GO GC est optimisé pour la faible latence . La majeure partie du marquage se produit pendant que votre programme fonctionne. Seules les pauses brèves d'arrêt du monde (STW) se produisent:

• Au début du marquage (pour configurer le processus).
• à la fin (pour finaliser le marquage).

Ces pauses se trouvent généralement dans la gamme de moins de millisecondes , ce qui rend Go adapté aux services sensibles à la latence.

Conseils pour les développeurs

Même si GC est automatique, vous pouvez influencer les performances:

• évitez de tenir des références à de grands objets plus longtemps que nécessaire.
• Réutilisez les objets via les pools ( sync.Pool ) pour les allocations à haute fréquence.
• Soyez conscient des fuites de mémoire des tranches / cartes globales ou des goroutines détenant des références.

 // Exemple: sync.pool pour réduire la pression d'allocation
var bufferpool = sync.pool {
    New: func () interface {} {return new (bytes.buffer)},
}

buf: = bufferpool.get (). (* bytes.buffer)
// Utilisez BUF
bufferpool.put (buf)

Fondamentalement, GO'S GC fonctionne tranquillement en arrière-plan, en utilisant la concurrence et le tra?age intelligents pour maintenir votre application en douceur avec un minimum de pauses. Ce n'est pas magique, mais il est bien réglé pour les applications modernes.

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!