Come sono strutturate le goroutine e quanta memoria occupano nello stack?

Una goroutine è un leggero thread di esecuzione gestito dall'ambiente di runtime di Go. A differenza dei thread del sistema operativo, le goroutine vengono multiplexate su un numero inferiore di thread del sistema operativo. Ciò garantisce una migliore scalabilità.

Aspetti chiave:

• Gestore scheduler (Scheduler): L'ambiente di runtime di Go ha il suo scheduler (scheduler M:N), che gestisce le goroutine (M) su un numero limitato di thread del sistema operativo (N).
• Gestore memoria (Memory Manager): Gestisce gli stack delle goroutine e la loro crescita/riduzione.
• Comunicazione: Le goroutine comunicano tramite canali, garantendo uno scambio di dati sicuro senza blocchi/mutex nella maggior parte dei casi.

Stack della goroutine:

• Inizialmente, gli stack delle goroutine sono piccoli, di solito 2 KB (prima di Go 1.4 erano 4 KB).
• Lo stack cresce e si riduce dinamicamente. Quando si verifica un overflow, si espande automaticamente, e quando si libera memoria, si comprime.
• Questa gestione dinamica dello stack riduce i costi rispetto agli stack grandi fissi del sistema operativo.

Memoria occupata nello stack:

• Al momento della creazione, una goroutine occupa generalmente 2 KB di memoria per il suo stack.
• Il consumo di memoria può aumentare dinamicamente con le chiamate di funzione e diminuire al ritorno.
• La dimensione massima dello stack è limitata, ma abbastanza grande per la maggior parte dei compiti (di solito diversi MB).

package main

import (
	"fmt"
	"runtime"
	"time"
)

func sayHello() {
	fmt.Println("Ciao da una goroutine!")
}

func main() {
	// Dimostrazione di creazione di una goroutine
	go sayHello()

	// Per osservare il funzionamento della goroutine
	time.Sleep(100 * time.Millisecond)

	fmt.Printf("Numero di goroutine: %d\n", runtime.NumGoroutine())
}

In questo esempio, sayHello viene eseguito come una goroutine separata. runtime.NumGoroutine() mostra il numero di goroutine attive (inclusa quella principale).