Comment définir des pointeurs sur Nil peut-il empêcher les fuites de mémoire dans Go ?

Définition des pointeurs sur Nil pour éviter les fuites de mémoire dans Golang

Les fuites de mémoire se produisent lorsque des objets sont inaccessibles par le programme en cours d'exécution, mais qu'ils utilisent toujours mémoire. Dans Go, les pointeurs sont des références à d'autres objets. Si un pointeur vers un objet est défini sur nil, l'objet devient inaccessible et le ramasse-miettes peut récupérer sa mémoire.

Dans l'exemple fourni, une liste chaînée est implémentée. La fonction de suppression définit les pointeurs suivant et précédent de l'élément supprimé sur zéro. Ceci est nécessaire pour éviter les fuites de mémoire car si ces pointeurs ne sont pas définis sur nil, ils référenceraient toujours l'élément supprimé et le ramasse-miettes ne pourrait pas récupérer sa mémoire.

Illustration d'une mémoire. Fuite

considérons le scénario suivant :

1. On crée un pointeur externe pointant vers Nœud2.
2. Nous supprimons les nœuds 2 à 4 de la liste.
3. Nous nous attendons à ce qu'à ce stade, seuls les nœuds 1, 2 et 5 soient vivants et le reste soit GC-ed . Cependant, étant donné que Node2 pointe toujours vers Node3 & etc., la chaîne entière reste non collectée.

Explication de la fuite de mémoire

Si un nœud dans le La liste chaînée a un pointeur externe pointant vers elle, alors tous les nœuds adjacents supprimés auront une référence active via ce pointeur et ne seront pas supprimé.

Définition des pointeurs sur Nil

En définissant les pointeurs next et prev de l'élément supprimé sur nil, nous brisons la chaîne de référence entre l'élément supprimé et le reste de la liste chaînée. Cela permet au garbage collector de récupérer la mémoire de l'élément supprimé et de ses valeurs associées.

Exemple

L'exemple suivant montre une fuite de mémoire dans Go et comment définir des pointeurs à zéro peut l'empêcher :

package main

import (
    "fmt"
    "runtime/debug"
)

type Node struct {
    Value int
    Next  *Node
    Prev  *Node
}

func main() {
    list := NewList()
    e1 := list.PushBack(1)
    e2 := list.PushBack(2)
    e2 = nil

    fmt.Println(e1.Value)

    // Trigger garbage collection to detect memory leak.
    debug.FreeOSMemory()

    // Memory leak detected:
    // runtime: memory is leaking
    // writing to 0x10c8aef60: ~[0]
    // Hint: call runtime.SetFinalizer
}

type List struct {
    Head *Node
    Tail *Node
    Len  int
}

func NewList() *List {
    return &List{Head: nil, Tail: nil, Len: 0}
}

func (l *List) PushBack(value int) *Node {
    e := &Node{Value: value, Next: nil, Prev: nil}
    if l.Head == nil {
        l.Head = e
    } else {
        l.Tail.Next = e
        e.Prev = l.Tail
    }
    l.Tail = e
    l.Len++
    return e
}

func (l *List) Remove(e *Node) *Node {
    if e == nil {
        return nil
    }

    if e.Prev != nil {
        e.Prev.Next = e.Next
    } else {
        l.Head = e.Next
    }

    if e.Next != nil {
        e.Next.Prev = e.Prev
    } else {
        l.Tail = e.Prev
    }

    e.Next = nil // avoid memory leaks
    e.Prev = nil // avoid memory leaks

    l.Len--
    return e
}

Dans cet exemple, le pointeur e2 est mis à zéro après avoir été supprimé de la liste, empêchant une mémoire fuir. Si e2 n'était pas défini sur nil, le garbage collector ne serait pas en mesure de récupérer la mémoire de l'élément supprimé et de ses valeurs associées, ce qui entraînerait une fuite de mémoire.

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!