Hoe werkt de garbage collector in de programmeertaal Go?

De garbage collector in Go implementeert een parallel, niet-precies (non-generational) methode gebaseerd op het Mark-and-Sweep algoritme met een trigger op basis van de heapgrootte.

Belangrijkste principes van werking:

1. Trigger voor activatie: De collector start wanneer de door het programma toegewezen geheugen de drempel overschrijdt, die dynamisch wordt geregeld.
2. Markeerfase (Mark Phase):
   • De collector pauzeert alleen het kritieke deel van de markeerfase (Stop-the-World, STW), maar dit duurt zeer kort.
   • Parallel met het lopende programma doorloopt de collector de objectgrafen vanaf de root pointers (registers, globale variabelen, goroutine stacks).
   • Bereikbare (levende) objecten worden gemarkeerd als gebruikt.
3. Schoonmaakfase (Sweep Phase):
   • Na voltooiing van de markeerfase doorloopt de collector de lijst van geheugen spans.
   • Niet-gemarkeerde objecten worden als afval beschouwd en hun geheugen wordt vrijgegeven.
   • Deze fase wordt ook parallel uitgevoerd met de programma-uitvoering.
4. Write Barrier: Go gebruikt een write barrier om wijzigingen in de objectgrafen tijdens de parallelle markeerfase bij te houden. Dit garandeert de correcte werking van de collector, ondanks geheugenwijzigingen door de mutator.
5. Geen generaties: In tegenstelling tot sommige andere talen, deelt Go objecten niet in generaties. De collector verwerkt de hele heap als één geheel.
6. Doel van lage latency: Bij het ontwerpen van de Go GC was het doel om de vertragingen door garbage collection (STW-pauzes) te minimaliseren, waardoor het geschikt is voor serverapplicaties.

Parallellisatie en gebruik van de write barrier stellen de collector in staat om de stoptijden van het programma te minimaliseren en hoge prestaties te garanderen.

Voorbeeld van een vereenvoudigd geheugenbeheer (niet direct GC, maar illustreert het vrijmaken van resources):

package main

import (
	"fmt"
	"os"
)

func main() {
	// Voorbeeld van het creëren van een tijdelijke resource die wordt vrijgegeven
	file, err := os.Create("temp.txt")
	if err != nil {
		fmt.Println("Fout bij het maken van het bestand:", err)
		return
	}
	// Uitgestelde sluiting van het bestand.
	// Hoewel dit geen GC in strikte zin is, toont het het vrijmaken van resources.
	defer file.Close()

	fmt.Println("Bestand 'temp.txt' aangemaakt.")

	// Vervolgens kan het programma met het bestand werken...

	// GC werkt automatisch op de achtergrond om niet-gebruikte objecten in de heap te verzamelen.
	// Bijvoorbeeld, als een slice of map wordt gemaakt:
	data := make([]int, 1000000) // Allocatie in de heap
	_ = data // Gebruik

	// Wanneer data niet meer bereikbaar is (bijvoorbeeld bij het verlaten van de functie),
	// zal de garbage collector na verloop van tijd het toegewezen geheugen vrijmaken.
}