Coleta de Lixo em Go

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

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

Quando você aloca memória usando new(), make() ou criando variáveis, o coletor de lixo do Go monitora essas alocações. Quando um valor não pode mais ser alcançado por nenhuma parte do seu programa, o GC libera essa memória automaticamente.

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 é 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 coletor de lixo gerencia apenas a memória do heap.

Esse gerenciamento automático de memória significa que você pode se concentrar em criar sua aplicação sem se preocupar com vazamentos de memória causados por desalocações esquecidas. No entanto, entender que o GC existe ajuda você a escrever um código mais eficiente, minimizando alocações desnecessárias quando o desempenho é importante.

Desafio

Fácil

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

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

session.go: Defina uma struct Session com campos ID (string), Username (string) e Data (uma fatia 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 a fatia Data como vazia. Adicione também um método AddData com um receptor ponteiro que anexa uma string à fatia 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: ID da sessão
Linha 2: Nome de usuário
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, com sess-001, alice, login e view_dashboard, sua saída deve ser:

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

A principal ideia 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 pilha, 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 faz isso automaticamente.

Experimente você mesmo

package main

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

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

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

	// Ler 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 já que 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("")
}