Bagaimanakah saya boleh mengoptimumkan penggunaan memori dan pengumpulan sampah dalam program Go saya apabila bekerja dengan rentetan dan penunjuk?

Pengumpulan Sampah dan Penggunaan Penunjuk yang Betul dalam Go

Latar Belakang pada Pengumpulan Sampah

Go menggunakan pengumpul sampah untuk mengurus memori secara automatik. Pengumpul sampah membebaskan memori yang tidak lagi dirujuk oleh mana-mana penunjuk.

Penunjuk dan Rentetan

Dalam Go, rentetan ialah nilai tidak berubah yang diluluskan oleh nilai. Apabila fungsi menerima rentetan, ia menerima salinan nilai rentetan, bukan rujukan kepada rentetan asal.

Menggunakan Penunjuk

Dalam kod yang disediakan, versi kod pemetaan berikut tidak optimum.

Versi 1:

tagToUrlMap := make(map[string][]*string)

for _, image := range result {
    for _, tag := range image.Tags {
        tagToUrlMap[tag.Name] = append(tagToUrlMap[tag.Name], &image.URL)
    }
}

Versi 2:

tagToUrlMap := make(map[string][]*string)

for _, image := range result {
    imageUrl = image.URL
    for _, tag := range image.Tags {
        tagToUrlMap[tag.Name] = append(tagToUrlMap[tag.Name], &imageUrl)
    }
}

Isu:

• Dalam kedua-dua versi, menyimpan alamat medan URL struct Imej akan menghalang struct Imej daripada menjadi sampah dikumpul.
• Versi 2 memperkenalkan tahap penyimpangan tambahan dan peruntukan objek yang tidak perlu.

Penyelesaian Optimum

Penyelesaian optimum ialah menggunakan kod berikut:

tagToUrlMap := make(map[string][]string)

for _, image := range result {
    imageURL := image.URL // Store the string value directly

    for _, tag := range image.Tags {
        tagName := tag.Name  // Store the string value directly
        tagToUrlMap[tagName] = append(tagToUrlMap[tagName], imageURL)
    }
}

String Interning

Kod ini mencipta rentetan baharu untuk setiap URL dan nama tag ditemui. Untuk mengoptimumkan penggunaan memori dengan lebih lanjut, string interning boleh digunakan.

String interning melibatkan penyimpanan nilai rentetan unik dalam cache pusat. Apabila rentetan baharu ditemui, ia diperiksa terhadap cache. Jika rentetan sudah berada dalam cache, nilai cache digunakan dan bukannya membuat rentetan baharu.

Berikut ialah interner rentetan mudah:

var cache = map[string]string

func intern(s string) string {
    if s2, ok := cache[s]; ok {
        return s2
    }
    cache[s] = s
    return s
}

Untuk menggunakan interner, ubah suai kod pemetaan seperti berikut:

tagToUrlMap := make(map[string][]string)

for _, image := range result {
    imageURL := intern(image.URL) // Intern the string

    for _, tag := range image.Tags {
        tagName := intern(tag.Name) // Intern the string
        tagToUrlMap[tagName] = append(tagToUrlMap[tagName], imageURL)
    }
}

Mengosongkan Cache

Untuk membebaskan memori yang digunakan oleh pelatih cache, tetapkan sifar kepada pembolehubah cache setelah latihan selesai:

cache = nil

Pengoptimuman Selanjutnya

• Selepas membina tagToUrlMap, potong sebarang kapasiti berlebihan daripada kepingan dalam peta ke simpan memori.
• Jika mahu, gunakan pengagih memori tersuai untuk mengoptimumkan memori lagi penggunaan.

Kesimpulan

Dengan menggunakan nilai rentetan secara langsung, rentetan interning dan mengosongkan cache interner, anda boleh mencapai penggunaan memori yang optimum dan pengumpulan sampah yang cekap dalam program Go anda.

Atas ialah kandungan terperinci Bagaimanakah saya boleh mengoptimumkan penggunaan memori dan pengumpulan sampah dalam program Go saya apabila bekerja dengan rentetan dan penunjuk?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!