Bagaimanakah Menetapkan Penunjuk kepada Nil Dapat Menghalang Kebocoran Memori dalam Go?

Menetapkan Penunjuk kepada Nil untuk Mengelakkan Kebocoran Memori di Golang

Kebocoran memori berlaku apabila objek tidak dapat dicapai oleh program yang sedang berjalan, tetapi masih menggunakan ingatan. Dalam Go, penunjuk ialah rujukan kepada objek lain. Jika penunjuk kepada objek ditetapkan kepada sifar, objek menjadi tidak boleh dicapai dan pemungut sampah boleh menuntut semula ingatannya.

Dalam contoh yang disediakan, senarai terpaut dilaksanakan. Fungsi alih keluar menetapkan penunjuk seterusnya dan sebelumnya bagi elemen yang dialih keluar kepada sifar. Ini adalah perlu untuk mengelakkan kebocoran memori kerana jika penunjuk ini tidak ditetapkan kepada sifar, ia akan tetap merujuk kepada elemen yang dialih keluar dan pengumpul sampah tidak akan dapat menuntut semula ingatannya.

Ilustrasi Memori Kebocoran

pertimbangkan senario berikut:

1. Kami mencipta luaran penunjuk menunjuk ke Node2.
2. Kami mengalih keluar nod 2-4 daripada senarai.
3. Kami menjangkakan pada ketika ini hanya untuk Nod 1, 2 & 5 akan hidup dan selebihnya akan GC-ed. Walau bagaimanapun, disebabkan Node2 masih menunjuk ke Node3 & dll., keseluruhan rantaian kekal tidak dikumpulkan.

Penjelasan Kebocoran Memori

Jika nod dalam senarai terpaut mempunyai penuding luaran yang menunjuk kepadanya, maka semua nod yang dialih keluar bersebelahan akan mempunyai rujukan aktif melalui penuding itu dan tidak akan dialih keluar.

Menetapkan Penunjuk kepada Nil

Dengan menetapkan penunjuk seterusnya dan sebelumnya bagi elemen yang dialih keluar kepada nil, kami memutuskan rantai rujukan antara elemen yang dialih keluar dan yang lain daripada senarai terpaut. Ini membolehkan pemungut sampah menuntut semula memori elemen yang dialih keluar dan nilai yang berkaitan dengannya.

Contoh

Contoh berikut menunjukkan kebocoran memori dalam Go dan cara menetapkan penunjuk kepada nil boleh menghalangnya:

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
}

Dalam contoh ini, penuding e2 ditetapkan kepada nil selepas dialih keluar daripada senarai, mengelakkan kebocoran memori. Jika e2 tidak ditetapkan kepada sifar, pemungut sampah tidak akan dapat menuntut semula memori elemen yang dialih keluar dan nilai yang berkaitan dengannya, mengakibatkan kebocoran memori.

Atas ialah kandungan terperinci Bagaimanakah Menetapkan Penunjuk kepada Nil Dapat Menghalang Kebocoran Memori dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!