Comment pouvez-vous utiliser Goroutines et WaitGroup pour télécharger plusieurs fichiers simultanément dans Go ?

Téléchargement simultané de plusieurs fichiers à l'aide de Goroutines dans Go

Introduction

Les Goroutines sont une puissante primitive de concurrence dans Go qui nous permet pour exécuter plusieurs tâches simultanément, améliorant ainsi les performances des applications et l'utilisation des ressources. Cet article montre comment exploiter la puissance des goroutines pour télécharger plusieurs fichiers en parallèle à partir d'un serveur distant.

Énoncé du problème

Nous avons un programme qui télécharge des fichiers depuis Dropbox en utilisant des requêtes HTTP GET. Cependant, nous observons que les téléchargements ne s’effectuent pas en parallèle, ce qui entraîne des performances sous-optimales. Notre objectif est de modifier le code pour exploiter les goroutines et exécuter les téléchargements simultanément.

Explication du code

Le code fourni comprend plusieurs fonctions responsables de l'autorisation et du téléchargement de fichiers depuis Dropbox. :

• download_file() : Cette fonction gère le téléchargement d'un seul fichier et son enregistrement localement.
• main() : Le principal la fonction autorise l'utilisateur et récupère la liste des fichiers à télécharger. Il lance ensuite le processus de téléchargement pour chaque fichier.

Implémentation de Goroutine

Pour activer les téléchargements parallèles, nous utilisons des goroutines en ajoutant le mot-clé go au fichier download_file( ) fonction. Cependant, cette approche échoue car notre goroutine principale se ferme avant la fin des téléchargements, ce qui entraîne une interruption prématurée du programme.

Pour résoudre ce problème, nous intégrons un sync.WaitGroup pour synchroniser les goroutines et garantir que la goroutine principale attend jusqu'à ce que tous les téléchargements soient terminés. Le WaitGroup ajoute un compteur pour chaque tâche de téléchargement, et chaque goroutine décrémente le compteur une fois le téléchargement terminé. Les principaux blocs goroutines sur le WaitGroup, attendent que le compteur atteigne zéro, permettant ainsi au programme de terminer tous les téléchargements avant de quitter.

Code modifié

Voici le code modifié code avec implémentation de goroutine et synchronisation WaitGroup :

<code class="go">package main

import (
    "encoding/json"
    "fmt"
    "io"
    "io/ioutil"
    "net/http"
    "net/url"
    "os"
    "path/filepath"
    "sync"
)

const app_key string = "<app_key>"
const app_secret string = "<app_secret>"

var code string

type TokenResponse struct {
    AccessToken string `json:"access_token"`
}

type File struct {
    Path string
}

type FileListResponse struct {
    FileList []File `json:"contents"`
}

func download_file(file File, token TokenResponse, wg *sync.WaitGroup) {
    // Download the file and save it locally.
    ...
    wg.Done() // Decrement the WaitGroup counter.
}

func main() {
    ...

    // Get file list.
    ...

    // Use a WaitGroup to synchronize the goroutines.
    var wg sync.WaitGroup
    for i, file := range flr.FileList {
        wg.Add(1) // Increment the WaitGroup counter.
        go download_file(file, tr, &wg) // Note the addition of the WaitGroup pointer.

        if i >= 2 {
            break
        }
    }
    wg.Wait() // Block the main goroutine until all downloads are complete.
}</code>

Conclusion

En incorporant des goroutines et un WaitGroup, notre programme télécharge désormais plusieurs fichiers en parallèle, améliorant considérablement les performances et tirer parti des capacités de concurrence de Go. Cette approche peut être appliquée à divers autres scénarios dans lesquels plusieurs tâches doivent être exécutées simultanément.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!