Décrypter Go : structure vide

Dans Go, une structure normale occupe généralement un bloc de mémoire. Cependant, il existe un cas particulier : s'il s'agit d'une structure vide, sa taille est nulle. Comment est-ce possible et à quoi sert une structure vide ?

Cet article est publié pour la première fois dans le plan moyen MPP. Si vous êtes un utilisateur moyen, suivez-moi en moyen. Merci beaucoup.

type Test struct {
    A int
    B string
}

func main() {
    fmt.Println(unsafe.Sizeof(new(Test)))
    fmt.Println(unsafe.Sizeof(struct{}{}))
}

/*
8
0
*/

Le secret de la structure vide

Variable spéciale : base zéro

Une structure vide est une structure sans taille de mémoire. Cette affirmation est correcte, mais pour être plus précis, elle a en fait un point de départ spécial : la variable de base zéro. Il s'agit d'une variable globale uintptr qui occupe 8 octets. Chaque fois que d'innombrables variables struct {} sont définies, le compilateur attribue l'adresse de cette variable de base zéro. En d'autres termes, dans Go, toute allocation mémoire d'une taille de 0 utilise la même adresse, &zerobase.

Exemple

package main

import "fmt"

type emptyStruct struct {}

func main() {
    a := struct{}{}
    b := struct{}{}
    c := emptyStruct{}

    fmt.Printf("%p\n", &a)
    fmt.Printf("%p\n", &b)
    fmt.Printf("%p\n", &c)
}

// 0x58e360
// 0x58e360
// 0x58e360

Les adresses mémoire des variables d'une structure vide sont toutes les mêmes. En effet, le compilateur attribue &zerobase lors de la compilation lorsqu'il rencontre ce type spécial d'allocation de mémoire. Cette logique est dans la fonction mallocgc :

//go:linkname mallocgc  
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {  
    ...
    if size == 0 {  
       return unsafe.Pointer(&zerobase)  
    }
    ...

C'est le secret de la structure Empty. Avec cette variable spéciale, nous pouvons accomplir de nombreuses fonctionnalités.

Structure vide et alignement de la mémoire

En général, si une structure vide fait partie d'une structure plus grande, elle n'occupe pas de mémoire. Cependant, il existe un cas particulier où la structure vide est le dernier champ ; cela déclenche l'alignement de la mémoire.

Exemple

type A struct {
    x int
    y string
    z struct{}
}
type B struct {
    x int
    z struct{}
    y string
}

func main() {
    println(unsafe.Alignof(A{}))
    println(unsafe.Alignof(B{}))
    println(unsafe.Sizeof(A{}))
    println(unsafe.Sizeof(B{}))
}

/**
8
8
32
24
**/

Lorsqu'un pointeur vers un champ est présent, l'adresse renvoyée peut être en dehors de la structure, ce qui peut entraîner des fuites de mémoire si la mémoire n'est pas libérée lorsque la structure est libérée. Par conséquent, lorsqu'une structure vide est le dernier champ d'une autre structure, de la mémoire supplémentaire est allouée pour des raisons de sécurité. Si la structure vide est au début ou au milieu, son adresse est la même que celle de la variable suivante.

type A struct {  
    x int  
    y string  
    z struct{}  
}  
type B struct {  
    x int  
    z struct{}  
    y string  
}  

func main() {  
    a := A{}  
    b := B{}  
    fmt.Printf("%p\n", &a.y)  
    fmt.Printf("%p\n", &a.z)  
    fmt.Printf("%p\n", &b.y)  
    fmt.Printf("%p\n", &b.z)  
}

/**
0x1400012c008
0x1400012c018
0x1400012e008
0x1400012e008
**/

Cas d'utilisation de la structure vide

La raison principale de l'existence du struct struct{} vide est de économiser de la mémoire. Lorsque vous avez besoin d'une structure mais que vous ne vous souciez pas de son contenu, envisagez d'utiliser une structure vide. Les structures composites de base de Go telles que map, chan et slice peuvent toutes utiliser struct{}.

carte et structure{}

// Create map
m := make(map[int]struct{})
// Assign value
m[1] = struct{}{}
// Check if key exists
_, ok := m[1]

chan et structure{}

Un scénario classique combine canal et struct{}, où struct{} est souvent utilisé comme signal sans se soucier de son contenu. Comme analysé dans les articles précédents, la structure de données essentielle d'un canal est une structure de gestion plus un tampon en anneau. Le tampon en anneau est alloué à zéro si struct{} est utilisé comme élément.

La seule utilisation de chan et struct{} ensemble est pour la transmission du signal puisque la structure vide elle-même ne peut porter aucune valeur. Généralement, il est utilisé sans canaux tampons.

// Create a signal channel
waitc := make(chan struct{})

// ...
goroutine 1:
    // Send signal: push element
    waitc <- struct{}{}
    // Send signal: close
    close(waitc)

goroutine 2:
    select {
    // Receive signal and perform corresponding actions
    case <-waitc:
    }    

Dans ce scénario, struct{} est-il absolument nécessaire ? Pas vraiment, et la mémoire économisée est négligeable. Le point clé est que la valeur de l'élément chan n'est pas prise en compte, c'est pourquoi struct{} est utilisé.

Résumé

1. Une structure vide est toujours une structure, juste avec une taille de 0.
2. Toutes les structures vides partagent la même adresse : l'adresse de Zerobase.
3. Nous pouvons exploiter la fonctionnalité de non-occupation de mémoire de la structure vide pour optimiser le code, par exemple en utilisant des cartes pour implémenter des ensembles et des canaux.

Références

1. La structure vide, Dave Cheney
2. Allez 最细节篇— struct{} 空结构体究竟是啥？

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!