Comment puis-je optimiser l'utilisation de la mémoire et le garbage collection dans mon programme Go lorsque je travaille avec des chaînes et des pointeurs ?

Garbage Collection et utilisation correcte des pointeurs dans Go

Contexte sur Garbage Collection

Go utilise un garbage collector pour gérer automatiquement la mémoire. Le garbage collector libère la mémoire qui n'est plus référencée par aucun pointeur.

Pointeurs et chaînes

Dans Go, les chaînes sont des valeurs immuables transmises par valeur. Lorsqu'une fonction reçoit une chaîne, elle reçoit une copie de la valeur de la chaîne, pas une référence à la chaîne d'origine.

Utilisation de pointeurs

Dans le code fourni, les versions suivantes du code de mappage ne sont pas optimaux.

Version 1 :

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

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

Version 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)
    }
}

Problèmes :

• Dans les deux versions, le stockage de l'adresse du champ URL de la structure Image empêchera la structure Image d'être récupérée.
• La version 2 introduit un niveau d'indirection supplémentaire et allocation d'objets inutiles.

Solution optimale

La solution optimale est d'utiliser le code suivant :

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

Ce code crée une nouvelle chaîne pour chaque URL et nom de balise rencontrés. Pour optimiser davantage l'utilisation de la mémoire, l'internement de chaînes peut être utilisé.

L'internement de chaînes implique le stockage de valeurs de chaîne uniques dans un cache central. Lorsqu'une nouvelle chaîne est rencontrée, elle est vérifiée par rapport au cache. Si la chaîne est déjà dans le cache, la valeur mise en cache est utilisée au lieu de créer une nouvelle chaîne.

Voici un simple interneur de chaîne :

var cache = map[string]string

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

Pour utiliser l'interner, modifiez le code de mappage comme suit :

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)
    }
}

Effacement du cache

Pour libérer la mémoire utilisée par le cache de l'internaire, attribuez nil à la variable de cache une fois l'internement terminé :

cache = nil

Autres optimisations

• Après avoir créé le tagToUrlMap, coupez toute capacité excédentaire des tranches de la carte pour économiser de la mémoire.
• Si vous le souhaitez, utilisez un allocateur de mémoire personnalisé pour optimiser davantage utilisation de la mémoire.

Conclusion

En utilisant directement les valeurs de chaîne, en interneant les chaînes et en vidant le cache de l'interne, vous pouvez obtenir une utilisation optimale de la mémoire et une récupération de place efficace dans votre programme Go.

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!