Basi delle goroutine

Fa parte della sezione Programmazione orientata agli oggetti del percorso GO di Coddy. Lezione 59 di 107.

Una goroutine è un thread di esecuzione leggero gestito dal runtime di Go. A differenza dei thread tradizionali, che consumano una quantità significativa di memoria, le goroutine iniziano con solo pochi kilobyte di spazio nello stack, consentendoti di eseguirne migliaia contemporaneamente.

Per avviare una goroutine, basta inserire la parola chiave go prima di una chiamata di funzione:

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

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

Quando viene eseguito go sayHello("Alice"), non aspetta che sayHello termini. Invece, passa subito alla riga successiva mentre sayHello viene eseguita in background. Ecco perché abbiamo bisogno di time.Sleep: senza di essa, main terminerebbe prima che le goroutine completino l'esecuzione.

Puoi anche avviare goroutine con funzioni anonime:

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

La funzione principale stessa viene eseguita in una goroutine. Quando termina, tutte le altre goroutine vengono terminate immediatamente. Non hanno la possibilità di finire. Usare time.Sleep è una soluzione temporanea; nelle prossime lezioni imparerai tecniche di sincronizzazione adeguate con i channel e i wait group.

Sfida

Facile

Costruiamo un esecutore di attività che esegue più attività contemporaneamente usando le goroutine. Creerai un semplice sistema in cui le attività vengono eseguite in background mentre il programma principale continua, mostrando come le goroutine consentano l'esecuzione concorrente.

Organizzerai il codice in due file:

tasks.go: definisci la logica di esecuzione delle attività.
Crea una struct Task con i campi Name (string) e Duration (int, che rappresenta i millisecondi).

Implementa un metodo Run() su Task che simula il lavoro attendendo per la durata dell'attività, poi stampa: Task [Name] completed

Crea una funzione RunAllTasks(tasks []Task) che avvia il metodo Run() di ogni attività come goroutine. Dopo aver avviato tutte le goroutine, dovrebbe attendere 500 millisecondi per consentire loro di completare, poi stampare: All tasks launched
main.go: leggi le informazioni sulle attività e coordina l'esecuzione concorrente.
Leggi il numero di attività, poi leggi il nome e la durata di ciascuna attività. Crea le attività e passale a RunAllTasks. Al termine della sua esecuzione, stampa: Main function done

Verranno forniti i seguenti input:

Riga 1: numero di attività (intero)
Righe successive: per ogni attività, due righe: il nome dell'attività, poi la sua durata in millisecondi

Per esempio, dato:

3
Download
100
Process
50
Upload
75

Il tuo output dovrebbe mostrare il completamento delle attività (l'ordine può variare a causa della concorrenza), seguito dai messaggi di completamento:

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

Nota: poiché le goroutine vengono eseguite contemporaneamente, le attività con durata minore terminano in genere per prime. L'ordine di completamento delle attività dipende dalle loro durate: quelle più brevi terminano prima di quelle più lunghe.

Usa time.Sleep con time.Duration e time.Millisecond per le attese. Ricorda che, senza l'attesa in RunAllTasks, la funzione restituirebbe il controllo prima che le goroutine abbiano terminato il loro lavoro.

Provalo tu

package main

import (
	"fmt"
)

func main() {
	// Leggi il numero di attività
	var numTasks int
	fmt.Scanln(&numTasks)

	// TODO: Crea uno slice per contenere le attività
	
	// TODO: Leggi il nome e la durata di ogni attività
	// Per ogni attività:
	//   - Leggi il nome dell'attività
	//   - Leggi la durata (come numero intero)
	//   - Crea un Task e aggiungilo al tuo slice

	// TODO: Chiama RunAllTasks con il tuo slice di attività

	// TODO: Stampa "Main function done"
}