Fundamentos de Goroutines

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

Uma goroutine é uma thread de execução leve gerenciada pelo Go runtime. Ao contrário das threads tradicionais que consomem uma memória significativa, as goroutines começam com apenas alguns kilobytes de espaço de pilha, permitindo que você execute milhares delas simultaneamente.

Para iniciar uma goroutine, basta colocar a palavra-chave go antes de uma chamada de função:

func sayHello(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    go sayHello("Alice")  // executa concorrentemente
    go sayHello("Bob")    // executa concorrentemente
    
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Done")
}

Quando go sayHello("Alice") executa, ele não espera por sayHello terminar. Em vez disso, ele continua imediatamente para a próxima linha enquanto sayHello roda em segundo plano. É por isso que precisamos de time.Sleep—sem isso, main sairia antes que as goroutines terminassem.

Você também pode iniciar goroutines com funções anônimas:

go func(msg string) {
    fmt.Println(msg)
}("Hello from goroutine")

A própria função main é executada em uma goroutine. Quando ela retorna, todas as outras goroutines são encerradas imediatamente — elas não têm a chance de terminar. Usar time.Sleep é uma solução temporária; nas próximas lições, você aprenderá técnicas de sincronização adequadas com channels e wait groups.

Desafio

Fácil

Vamos construir um executor de tarefas que executa múltiplas tarefas simultaneamente usando goroutines. Você criará um sistema simples onde as tarefas rodam em segundo plano enquanto o programa principal continua, demonstrando como as goroutines permitem a execução concorrente.

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

tasks.go: Defina sua lógica de execução de tarefas.
Crie uma struct Task com os campos Name (string) e Duration (int, representando milissegundos).

Implemente um método Run() em Task que simula o trabalho pausando (sleeping) pela duração da tarefa e, em seguida, imprime: Task [Name] completed

Crie uma função RunAllTasks(tasks []Task) que inicia o método Run() de cada tarefa como uma goroutine. Após iniciar todas as goroutines, ela deve pausar por 500 milissegundos para permitir que elas terminem e, então, imprimir: All tasks launched
main.go: Leia as informações das tarefas e orquestre a execução concorrente.
Leia o número de tarefas e, em seguida, leia o nome e a duração de cada tarefa. Crie as tarefas e passe-as para RunAllTasks. Após o retorno da função, imprima: Main function done

As seguintes entradas serão fornecidas:

Linha 1: Número de tarefas (inteiro)
Linhas seguintes: Para cada tarefa, duas linhas - o nome da tarefa e, em seguida, sua duração em milissegundos

Por exemplo, dado:

3
Download
100
Process
50
Upload
75

Sua saída deve mostrar as tarefas sendo concluídas (a ordem pode variar devido à concorrência), seguidas pelas mensagens de conclusão:

Task Process completed
Task Upload completed
Task Download completed
All tasks launched
Main function done

Nota: Como as goroutines rodam simultaneamente, tarefas com durações mais curtas geralmente terminam primeiro. A ordem de conclusão das tarefas depende de suas durações - tarefas mais curtas terminam antes das mais longas.

Use time.Sleep com time.Duration e time.Millisecond para os atrasos. Lembre-se de que, sem a pausa em RunAllTasks, a função retornaria antes que as goroutines terminassem seu trabalho.

Folha de consulta

Uma goroutine é uma thread de execução leve gerenciada pelo runtime do Go. Goroutines começam com apenas alguns kilobytes de espaço de pilha, permitindo que você execute milhares delas simultaneamente.

Para iniciar uma goroutine, coloque a palavra-chave go antes de uma chamada de função:

func sayHello(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    go sayHello("Alice")  // executa simultaneamente
    go sayHello("Bob")    // executa simultaneamente
    
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Done")
}

Quando go sayHello("Alice") é executado, ele não espera que sayHello termine. Em vez disso, ele continua imediatamente para a próxima linha enquanto sayHello é executado em segundo plano.

Você pode iniciar goroutines com funções anônimas:

go func(msg string) {
    fmt.Println(msg)
}("Hello from goroutine")

A própria função main é executada em uma goroutine. Quando ela retorna, todas as outras goroutines são encerradas imediatamente. Use time.Sleep para permitir que as goroutines terminem antes que a função main saia.

Experimente você mesmo

package main

import (
	"fmt"
)

func main() {
	// Lê o número de tarefas
	var numTasks int
	fmt.Scanln(&numTasks)

	// TODO: Cria um slice para armazenar as tarefas
	
	// TODO: Lê o nome e a duração de cada tarefa
	// Para cada tarefa:
	//   - Lê o nome da tarefa
	//   - Lê a duração (como inteiro)
	//   - Cria uma Task e adiciona ao seu slice

	// TODO: Chama RunAllTasks com o seu slice de tarefas

	// TODO: Imprime "Main function done"
}