Garbage Collection em Go

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy — lição 23 de 107.

Ao contrário de linguagens como C ou C++, o Go gerencia a memória automaticamente por meio da coleta de lixo (garbage collection - GC). Você não precisa liberar memória manualmente quando terminar de usá-la. O runtime do Go rastreia qual memória ainda está em uso e recupera o restante.

Quando você aloca memória usando new(), make() ou criando variáveis, o garbage collector do Go monitora essas alocações. Assim que um valor não for mais acessível por qualquer parte do seu programa, o GC libera automaticamente essa memória.

func createPerson() *Person {
    p := &Person{Name: "Alice", Age: 30}
    return p  // p escapa para o heap, o GC irá gerenciá-lo
}

func main() {
    person := createPerson()
    fmt.Println(person.Name)
    // Quando person não for mais usado, o GC recupera a memória
}

Neste exemplo, a struct Person é alocada no heap porque é retornada pela função. O compilador do Go realiza análise de escape para determinar se uma variável pode permanecer na stack ou deve ser movida para o heap. O garbage collector gerencia apenas a memória heap.

Este gerenciamento automático de memória significa que você pode se concentrar em construir sua aplicação sem se preocupar com vazamentos de memória decorrentes de desalocações esquecidas. No entanto, entender que o GC existe ajuda você a escrever códigos mais eficientes, minimizando alocações desnecessárias quando a performance é importante.

Desafio

Fácil

Vamos construir um gerenciador de sessões que demonstra como o coletor de lixo (garbage collector) do Go lida com a memória para objetos que escapam para o heap. Você criará sessões que são alocadas dinamicamente e retornadas de funções, permitindo que o GC gerencie seu ciclo de vida.

Você organizará seu código em dois arquivos:

session.go: Defina uma struct Session com os campos ID (string), Username (string) e Data (um slice de strings). Crie uma função NewSession que recebe um ID e um nome de usuário, aloca uma nova Session no heap (retornando um ponteiro) e inicializa o slice Data como vazio. Adicione também um método AddData com um receptor de ponteiro (pointer receiver) que anexa uma string ao slice Data da sessão, e um método Summary que retorna uma string formatada mostrando os detalhes da sessão.
main.go: Leia as informações da sessão da entrada, crie uma sessão usando sua função construtora, adicione algumas entradas de dados a ela e exiba o resumo da sessão. Como a sessão é criada dentro de uma função e retornada como um ponteiro, ela escapa para o heap, onde o coletor de lixo a gerenciará.

As seguintes entradas serão fornecidas:

Linha 1: Session ID
Linha 2: Username
Linha 3: Primeira entrada de dados a adicionar
Linha 4: Segunda entrada de dados a adicionar

Seu método Summary deve retornar uma string neste formato:

Session [ID] for user [Username]
Data entries: [count]
- [entry1]
- [entry2]

Por exemplo, dados sess-001, alice, login e view_dashboard, sua saída deve ser:

Session sess-001 for user alice
Data entries: 2
- login
- view_dashboard

O ponto principal aqui é que sua função NewSession cria uma Session e retorna um ponteiro para ela. Isso faz com que a Session "escape" para o heap em vez de permanecer na stack, tornando-a elegível para a coleta de lixo assim que não restarem referências a ela. Seu código não precisa liberar essa memória manualmente — o Go cuida disso automaticamente.

Folha de consulta

Go usa garbage collection (GC) para o gerenciamento automático de memória. Você não precisa liberar memória manualmente.

O garbage collector rastreia alocações de memória e recupera a memória que não é mais acessível pelo seu programa.

func createPerson() *Person {
    p := &Person{Name: "Alice", Age: 30}
    return p  // p escapa para o heap, o GC irá gerenciá-lo
}

func main() {
    person := createPerson()
    fmt.Println(person.Name)
    // Quando person não for mais usado, o GC recupera a memória
}

O compilador do Go realiza escape analysis para determinar se uma variável permanece na stack ou se move para o heap. Variáveis que escapam para o heap (como ponteiros retornados) são gerenciadas pelo garbage collector.

O GC gerencia apenas a memória heap, não a memória stack. A memória stack é liberada automaticamente quando uma função retorna.

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Ler o ID da sessão
	sessionID, _ := reader.ReadString('\n')
	sessionID = sessionID[:len(sessionID)-1]

	// Ler o nome de usuário
	username, _ := reader.ReadString('\n')
	username = username[:len(username)-1]

	// Ler a primeira entrada de dados
	data1, _ := reader.ReadString('\n')
	data1 = data1[:len(data1)-1]

	// Ler a segunda entrada de dados
	data2, _ := reader.ReadString('\n')
	data2 = data2[:len(data2)-1]

	// TODO: Criar uma nova sessão usando a função NewSession
	// A sessão escapará para o heap, pois retornamos um ponteiro

	// TODO: Adicionar as entradas de dados à sessão usando o método AddData

	// TODO: Imprimir o resumo da sessão usando o método Summary
	fmt.Println("")
}