Go: download multipli con goroutine e channel

  • Go
  • Gabriele Romanato

Go è un linguaggio di programmazione concorrente noto per la sua facilità d'uso nel gestire il parallelismo e la concorrenza. Una delle caratteristiche più potenti di Go è l'utilizzo delle goroutine e dei channel per gestire processi paralleli in modo efficiente. In questo articolo, esploreremo come implementare il download multiplo di file utilizzando le goroutine e i channel in Go.

Introduzione alle Goroutine

Una goroutine è un thread leggero gestito dal runtime di Go. Le goroutine consentono di eseguire funzioni in modo asincrono, rendendo più semplice gestire il parallelismo nei programmi. Per creare una goroutine in Go, basta utilizzare la parola chiave go prima di una funzione:


go myFunc()

Questo avvierà myFunc() in una goroutine separata.

Utilizzo dei Channel

I channel sono strutture dati fondamentali per la comunicazione tra goroutine. Per dichiarare un channel in Go, è possibile utilizzare la seguente sintassi:


myChannel := make(chan tipoDati)

I channel possono essere utilizzati per inviare e ricevere dati tra goroutine. Possono essere utilizzati per sincronizzare le operazioni e condividere dati in modo sicuro.

Implementazione del Download Multiplo

Per implementare il download multiplo di file con le goroutine e i channel in Go, seguiremo questi passaggi:

  1. Creare una lista di URL dei file da scaricare.
  2. Creare un channel per comunicare tra le goroutine.
  3. Creare una goroutine per ogni URL per gestire il download.
  4. Ricevere i dati scaricati tramite i channel e salvarli su disco.

Ecco un esempio di codice che implementa questo processo:


package main

import (
    "fmt"
    "io"
    "log" 
    "net/http"
    "net/url"
    "path/filepath"
    "os"
)

func downloadFile(url string, ch chan string) {
    response, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprintf("Errore durante il download di %s: %s", url, err)
        return
    }
    defer response.Body.Close()

    filename := getFileName(url)

    out, err := os.Create(filename)
    if err != nil {
        ch <- fmt.Sprintf("Errore durante la creazione del file %s: %s", filename, err)
        return
    }
    defer out.Close()

    _, err = io.Copy(out, response.Body)
    if err != nil {
        ch <- fmt.Sprintf("Errore durante la scrittura del file %s: %s", filename, err)
        return
    }

    ch <- fmt.Sprintf("%s scaricato con successo", url)
}

func getFileName(urlstr string) string {
    u, err := url.Parse(urlstr)
    if err != nil {
	log.Fatal("Error due to parsing url: ", err)
    }
    
    ex, _ := url.QueryUnescape(u.EscapedPath())
    return filepath.Base(ex)        
}

func main() {
    urls := []string{
        "https://example.com/file1.txt",
        "https://example.com/file2.txt",
        "https://example.com/file3.txt",
    }

    ch := make(chan string)

    for _, url := range urls {
        go downloadFile(url, ch)
    }

    for range urls {
        fmt.Println(<-ch)
    }
}

In questo esempio, abbiamo creato una funzione downloadFile() che scarica un file da un URL specifico e utilizza un channel ch per comunicare il risultato del download. Nella funzione main(), avviamo una goroutine separata per ogni URL da scaricare, e successivamente attendiamo che tutte le goroutine terminino e stampiamo i risultati.

Conclusioni

Go offre un'eccellente supporto per la programmazione concorrente utilizzando le goroutine e i channel. Con questa implementazione di download multiplo, è possibile sfruttare appieno il potenziale di Go per eseguire operazioni parallele in modo efficiente e sicuro. Sperimentate con questo codice di base per gestire download più complessi o altre attività parallele nei vostri progetti Go.

Torna su