Parlons de la façon d'ouvrir plusieurs coroutines en langage Go

Ces dernières années, le langage Go est devenu l'un des langages de programmation les plus populaires dans le domaine Internet et présente d'excellentes performances dans le domaine de la concurrence à grande échelle et des hautes performances. Lors du traitement de demandes simultanées, l’ouverture de plusieurs coroutines Go est un moyen important d’améliorer les performances du système et la vitesse de réponse. Alors, comment ouvrir plus de coroutines Go ?

Goroutine en langage Go est similaire au thread, mais plus léger et efficace. Grâce à goroutine, nous pouvons facilement implémenter des traitements multitâches tels que le calcul parallèle et les E/S asynchrones.

Tout d'abord, jetons un coup d'œil à un exemple simple qui montre comment utiliser goroutine pour gérer plusieurs requêtes en même temps :

func main() {
    urls := []string{
        "http://www.google.com/",
        "http://www.apple.com/",
        "http://www.microsoft.com/",
        "http://www.facebook.com/",
    }

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

    time.Sleep(time.Second)
}

func request(url string) {
    resp, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(url, len(body))
}

Le code ci-dessus montre comment récupérer le contenu de plusieurs sites Web simultanément. Nous utilisons goroutine pour gérer simultanément. chaque demande. Cependant, dans les applications réelles, si nous utilisons directement le code ci-dessus, cela peut entraîner la création d'un trop grand nombre de goroutines et même provoquer un crash du système.

Par conséquent, nous devons contrôler le nombre de goroutines grâce à l'optimisation afin qu'elles puissent fonctionner dans les limites de la tolérance de charge du système.

Tout d'abord, nous pouvons contrôler la concurrence en limitant le nombre de goroutines. Dans le langage Go, vous pouvez utiliser waitgroup (un type d'outil dans le package de synchronisation) pour contrôler le nombre de goroutines.

Ce qui suit est un exemple de programme :

func main() {
    urls := []string{
        "http://www.google.com/",
        "http://www.apple.com/",
        "http://www.microsoft.com/",
        "http://www.facebook.com/",
    }

    var wg sync.WaitGroup
    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            request(url)
            wg.Done()
        }(url)
    }

    wg.Wait()
}

func request(url string) {
    resp, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(url, len(body))
}

Dans le code ci-dessus, WaitGroup est utilisé pour contrôler le nombre de goroutines. Lorsqu'une goroutine appelle la méthode waitgroup.Add(1), cela signifie qu'une goroutine doit être démarrée pour traiter la requête et lorsque la goroutine a fini de traiter la requête, elle doit appeler la méthode waitgroup.Done(), ce qui signifie ; qu'une tâche a été accomplie.

De plus, nous pouvons également utiliser le mécanisme de mise en mémoire tampon de l'instruction go pour contrôler la concurrence. Le canal en langage Go peut nous aider à réaliser la communication entre les goroutines et peut être utilisé pour contrôler la planification entre les goroutines. Les canaux mis en cache peuvent limiter la concurrence et ainsi contrôler le nombre de goroutines.

Ce qui suit est un exemple de programme :

func main() {
    urls := []string{
        "http://www.google.com/",
        "http://www.apple.com/",
        "http://www.microsoft.com/",
        "http://www.facebook.com/",
    }

    var wg sync.WaitGroup
    ch := make(chan string, 2)
    for _, url := range urls {
        ch <- url
        wg.Add(1)
        go func() {
            defer wg.Done()
            request(<-ch)
        }()
    }

    wg.Wait()
}

func request(url string) {
    resp, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(url, len(body))
}

Dans le code ci-dessus, nous utilisons un canal en cache et créons un canal d'une capacité de 2 pour limiter le nombre de goroutines. Dans le même temps, nous utilisons WaitGroup pour attendre la fin de toutes les goroutines avant la fin du programme.

En résumé, pour ouvrir plusieurs coroutines Go, vous devez procéder comme suit :

1. Contrôler raisonnablement le nombre de goroutines pour éviter une charge excessive du système causée par une création excessive de goroutines.
2. Utilisez des mécanismes tels que WaitGroup et Channel pour contrôler la concurrence et éviter la concurrence et les problèmes de planification entre les goroutines.
3. Utilisez les ressources système de manière rationnelle, traitez les demandes simultanément et améliorez la vitesse de réponse et les performances du système.

Bien sûr, ce qui précède n'est qu'une idée et une méthode pour ouvrir davantage de coroutines Go. Dans la production réelle, nous devons encore optimiser et concevoir en fonction de besoins spécifiques. Je pense qu'avec ces connaissances de base, vous serez en mesure de mieux gérer le problème des coroutines multiples en langage Go.

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!