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 runtime do Go. Diferentemente das threads tradicionais, que consomem uma quantidade significativa de memória, 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") é executado, ele não espera que sayHello termine. Em vez disso, continua imediatamente para a próxima linha enquanto sayHello é executado em segundo plano. É por isso que precisamos de time.Sleep; sem ele, main seria encerrado antes que as goroutines fossem concluídas.

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 principal é 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 adequadas de sincronização com canais e grupos de espera.

Desafio

Fácil

Vamos criar um executor de tarefas que executa várias tarefas simultaneamente usando goroutines. Você criará um sistema simples no qual as tarefas são executadas 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 a lógica de execução das tarefas.
Crie uma struct Task com os campos Name (string) e Duration (int, representando milissegundos).

Implemente um método Run() em Task que simule o trabalho dormindo durante a duração da tarefa e, em seguida, imprima: Task [Name] completed

Crie uma função RunAllTasks(tasks []Task) que inicie o método Run() de cada tarefa como uma goroutine. Depois de iniciar todas as goroutines, ela deverá dormir por 500 milissegundos para permitir que sejam concluídas e, em seguida, imprimir: All tasks launched
main.go: Leia as informações das tarefas e coordene 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. Depois que ela retornar, 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, considerando:

3
Download
100
Process
50
Upload
75

Sua saída deverá 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

Observação: Como as goroutines são executadas simultaneamente, as tarefas com durações menores normalmente terminam primeiro. A ordem de conclusão das tarefas depende de suas durações — tarefas mais curtas são concluídas antes das mais longas.

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

Experimente você mesmo

package main

import (
	"fmt"
)

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

	// TODO: Crie um slice para armazenar as tarefas
	
	// TODO: Leia o nome e a duração de cada tarefa
	// Para cada tarefa:
	//   - Leia o nome da tarefa
	//   - Leia a duração (como inteiro)
	//   - Crie um Task e adicione ao seu slice

	// TODO: Chame RunAllTasks com seu slice de tarefas

	// TODO: Print "Main function done"
}