Come funziona il garbage collector nel linguaggio Go?

Il garbage collector in Go implementa un metodo parallelo, impreciso (non-generazionale), basato sull'algoritmo Mark-and-Sweep con un trigger basato sul volume dell'heap.

Principi di funzionamento principali:

1. Trigger di attivazione: Il collector si avvia quando il volume di memoria assegnato dal programma supera una soglia, regolata dinamicamente.
2. Fase di marcatura (Mark Phase):
   • Il collector sospende solo la parte critica della fase di marcatura (Stop-the-World, STW), ma questa dura molto poco.
   • In parallelo con il programma in esecuzione (mutator), il collector attraversa il grafo di oggetti dai puntatori radice (registri, variabili globali, stack delle goroutine).
   • Gli oggetti raggiungibili (vivi) vengono marcati come usati.
3. Fase di scansione (Sweep Phase):
   • Dopo aver completato la fase di marcatura, il collector attraversa la lista degli span di memoria.
   • Gli oggetti non marcati sono considerati rifiuti e la loro memoria viene liberata.
   • Questa fase viene eseguita anche in parallelo con l'esecuzione del programma.
4. Barriera di scrittura (Write Barrier): Go utilizza una barriera di scrittura per tracciare le modifiche al grafo di oggetti durante la fase di marcatura parallela. Ciò garantisce il corretto funzionamento del collector, nonostante le modifiche alla memoria da parte del mutator.
5. Nessuna generazione: A differenza di alcuni altri linguaggi, Go non divide gli oggetti in generazioni. Il collector elabora l'intera heap nel suo insieme.
6. Obiettivo di bassa latenza: Nel progettare il GC di Go, si è cercato di minimizzare le pause causate dalla raccolta dei rifiuti (STW), rendendolo adatto alle applicazioni server.

La parallelizzazione e l'uso della barriera di scrittura consentono al collector di minimizzare i tempi di fermo del programma, garantendo alte prestazioni.

Esempio di gestione della memoria semplificata (non direttamente GC, ma illustra il rilascio delle risorse):

package main

import (
	"fmt"
	"os"
)

func main() {
	// Esempio di creazione di una risorsa temporanea che verrà liberata
	file, err := os.Create("temp.txt")
	if err != nil {
		fmt.Println("Errore creazione file:", err)
		return
	}
	// Chiusura differita del file.
	// Sebbene non sia GC in senso stretto, dimostra il rilascio delle risorse.
	defer file.Close()

	fmt.Println("File 'temp.txt' creato.")

	// Successivamente, il programma può lavorare con il file...

	// Il GC funziona automaticamente in background per raccogliere oggetti non più raggiungibili in heap.
	// Ad esempio, se si crea uno slice o una mappa:
	data := make([]int, 1000000) // Assegnazione in heap
	_ = data // Uso

	// Quando data non sarà più raggiungibile (ad esempio, uscendo dalla funzione),
	// il garbage collector libererà nel tempo la memoria allocata.
}