Quelles sont les performances du modèle de concurrence en langage Go ?

Ces dernières années, le modèle de concurrence du langage Go est devenu de plus en plus populaire parmi les développeurs. Comparés aux modèles de concurrence d'autres langages, Goroutine et Channel utilisés dans Go sont plus légers et plus faciles à utiliser. Ainsi, dans des scénarios d’application réels, quel type de performances le modèle de concurrence du langage Go offre-t-il ?

Le modèle de concurrence du langage Go adopte les concepts de conception de Goroutine et Channel, visant à améliorer l'efficacité des opérations simultanées. Goroutine peut être considéré comme un thread léger, et ses coûts de démarrage et de destruction sont bien inférieurs à ceux des threads traditionnels. Le canal peut être considéré comme un « pipeline » de communication entre les Goroutines, chargés de transmettre les données. Par rapport au mécanisme de verrouillage, Channel est plus efficace pour réaliser la synchronisation et l'exclusion mutuelle entre les coroutines.

Dans les scénarios où le nombre de tâches simultanées est faible, les performances du modèle de concurrence de Go ne sont pas évidentes. Cependant, le modèle de concurrence de Go fonctionne bien dans des scénarios tels que le calcul parallèle à grande échelle et les opérations d'E/S. Dans ces scénarios, les performances du modèle de concurrence de Go peuvent même surpasser les programmes multithread traditionnels.

Prenons comme exemple les applications gourmandes en calcul pour comparer les performances du modèle de concurrence Go et du multithreading Python. Dans ce scénario d'application, on s'attend à ce que le nombre de tâches simultanées soit important, l'intensité de calcul soit élevée et les exigences informatiques soient relativement élevées. Vous pouvez implémenter un scénario de test en deux langues pour voir leurs performances.

Le premier est l'implémentation du multi-threading Python :

import threading

NUM_THREADS = 1000
NUM_STEPS = 1000000

def calculate_pi(start, end, step):
    pi = 0
    for i in range(start, end):
        x = (i + 0.5) * step
        pi += 4.0 / (1.0 + x * x)
    return pi

threads = []

for i in range(NUM_THREADS):
    start = int(i * NUM_STEPS / NUM_THREADS)
    end = int((i+1) * NUM_STEPS / NUM_THREADS)
    thread = threading.Thread(target=calculate_pi, args=(start, end, 1/NUM_STEPS))
    threads.append(thread)

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

Le multi-threading Python est utilisé ici, et 1000 threads sont activés pour le calcul. Les résultats des tests montrent que l'exécution du programme prend environ 71 secondes.

Voici ensuite comment le modèle de concurrence Go est implémenté :

package main

import (
    "sync"
)

const (
    numThreads = 1000
    numSteps = 1000000
)

func calculatePi(start int, end int, step float64, wg *sync.WaitGroup, ch chan float64) {
    pi := 0.0
    for i := start; i < end; i++ {
        x := (float64(i) + 0.5) * step
        pi += 4.0 / (1.0 + x * x)
    }
    ch <- pi
    wg.Done()
}

func main() {
    wg := &sync.WaitGroup{}
    ch := make(chan float64, numThreads)

    for i := 0; i < numThreads; i++ {
        start := int(float64(i) * float64(numSteps) / float64(numThreads))
        end := int(float64(i+1) * float64(numSteps) / float64(numThreads))
        wg.Add(1)
        go calculatePi(start, end, 1.0/float64(numSteps), wg, ch)
    }

    wg.Wait()
    close(ch)

    pi := 0.0
    for result := range ch {
        pi += result
    }

    pi *= 1.0 / float64(numSteps)

    fmt.Println(pi)
}

Les résultats des tests montrent que la durée d'exécution de ce programme est d'environ 17 secondes. Comparé au multithreading Python, le modèle de concurrence Go est nettement plus efficace.

Bien sûr, le modèle de concurrence du langage Go présente également certaines limites. Par exemple, dans un scénario gourmand en CPU, en raison du mécanisme de collaboration de Goroutine, GOMAXPROCS (c'est-à-dire le nombre de cœurs de CPU) peut être insuffisamment occupé, affectant les performances du programme. Mais d'une manière générale, dans des scénarios tels que le calcul parallèle à grande échelle et les opérations d'E/S, le modèle de concurrence du langage Go fonctionne très bien et peut améliorer considérablement l'efficacité et les performances du programme.

Pour résumer, compte tenu de l'effet d'utilisation dans les scénarios d'application réels et de la commodité du fonctionnement du développeur, le modèle de concurrence Go est sans aucun doute un meilleur modèle de concurrence actuellement.

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!