Comment créer des indicateurs chargés pour les processus de longue durée dans Go à l'aide de goroutines ?

Création d'indicateurs d'occupation pour les processus exécutés

Lors de l'exécution de processus enfants qui prennent une durée prolongée, il est crucial de fournir aux utilisateurs un moyen de savoir que le processus est effectivement en cours. Sans indicateur, les utilisateurs peuvent ne pas être conscients de la progression ou même penser que le système ne répond plus.

Pour résoudre ce problème, divers indicateurs d'occupation peuvent être mis en œuvre pour fournir des repères visuels à l'utilisateur. L'un de ces indicateurs consiste à imprimer périodiquement un caractère, tel qu'un point ou une barre de progression, sur la console.

Utiliser les Goroutines pour les indicateurs d'occupation

Les Goroutines sont des threads légers dans le langage de programmation Go, qui peut être utilisé pour créer un thread distinct chargé de gérer l'indicateur d'occupation. Voici comment cela peut être accompli :

<code class="go">func indicator(shutdownCh <-chan struct{}) {
    ticker := time.NewTicker(time.Second)
    defer ticker.Stop()
    for {
        select {
        case <-ticker.C:
            fmt.Print(".")
        case <-shutdownCh:
            return
        }
    }
}

func main() {
    cmd := exec.Command("npm", "install")
    log.Printf("Running command and waiting for it to finish...")

    // Start indicator:
    shutdownCh := make(chan struct{})
    go indicator(shutdownCh)

    err := cmd.Run()

    close(shutdownCh) // Signal indicator() to terminate

    fmt.Println()
    log.Printf("Command finished with error: %v", err)
}</code>

Dans cet exemple, une goroutine nommée Indicator() est créée et imprime périodiquement un point sur la console. La goroutine continue d'imprimer jusqu'à ce qu'un signal soit reçu du canal shutdownCh. Lorsque le processus enfant est terminé, la goroutine principale ferme shutdownCh, ce qui entraîne la fin de la goroutine Indicator() et l'arrêt de l'impression des points.

Personnalisation des indicateurs d'occupation

L'indicateur d'occupation peut être davantage personnalisé en ajustant la vitesse à laquelle il s'imprime ou en ajoutant différents caractères ou motifs. Par exemple, pour imprimer un point toutes les secondes et une nouvelle ligne tous les 5 points, la fonction Indicator() peut être modifiée comme suit :

<code class="go">func indicator(shutdownCh <-chan struct{}) {
    ticker := time.NewTicker(time.Second)
    defer ticker.Stop()
    for i := 0; ; {
        select {
        case <-ticker.C:
            fmt.Print(".")
            if i++; i%5 == 0 {
                fmt.Println()
            }
        case <-shutdownCh:
            return
        }
    }
}</code>

En incorporant un indicateur occupé dans votre application, vous pouvez fournir aux utilisateurs une expérience plus réactive et conviviale, leur assurant que leur processus s'exécute en arrière-plan pendant qu'ils attendent les résultats.

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!