Como são estruturadas as goroutines e quanto de memória elas ocupam na pilha?

Uma goroutine é um fio de execução leve gerido pelo ambiente de execução do Go. Ao contrário dos fios do sistema operativo, as goroutines são multiplexadas num menor número de fios do sistema operativo. Isto garante uma melhor escalabilidade.

Aspectos-chave:

• Gestor de agendamento (Scheduler): O ambiente de execução do Go tem o seu próprio agendador (agendador M:N), que gere as goroutines (M) num número limitado de fios do sistema operativo (N).
• Gestor de memória (Memory Manager): Gerir as pilhas das goroutines e o seu crescimento/diminuição.
• Comunicação: As goroutines comunicam através de canais, garantindo uma troca de dados segura sem bloqueios/mutexes na maioria dos casos.

Pilha da goroutine:

• Inicialmente, as pilhas das goroutines são pequenas, geralmente 2 KB (antes do Go 1.4 eram 4 KB).
• A pilha é dinâmica, crescendo e encolhendo. Quando transborda, expande-se automaticamente, e quando liberta memória, encolhe.
• Esta gestão dinâmica da pilha reduz os custos em comparação com pilhas fixas grandes do sistema operativo.

Memória ocupada na pilha:

• Quando criada, uma goroutine ocupa geralmente 2 KB de memória para a sua pilha.
• O consumo de memória pode aumentar dinamicamente com chamadas de funções e diminuir ao retornar.
• O tamanho máximo da pilha é limitado, mas é suficientemente grande para a maioria das tarefas (geralmente vários MB).

package main

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

func sayHello() {
	fmt.Println("Olá de uma goroutine!")
}

func main() {
	// Demonstração de criação de uma goroutine
	go sayHello()

	// Para observar o funcionamento da goroutine
	time.Sleep(100 * time.Millisecond)

	fmt.Printf("Número de goroutines: %d\n", runtime.NumGoroutine())
}

Neste exemplo, sayHello é executado como uma goroutine separada. runtime.NumGoroutine() mostra o número de goroutines ativas (incluindo a principal).