Golang implémente le parallélisme

Avec le développement rapide du big data, de l'intelligence artificielle et d'autres technologies, la demande de hautes performances et de haute simultanéité devient également de plus en plus élevée. Dans ce contexte, Golang est très populaire en tant que langage de programmation à haute concurrence et hautes performances. Parmi elles, les fonctionnalités parallèles de Golang sont l'une de ses caractéristiques importantes qui le distinguent des autres langages. Cet article explique principalement comment implémenter le parallélisme dans Golang et les améliorations de performances apportées par le parallélisme.

1. Aperçu du parallélisme

Parallèle fait référence à l'exécution de plusieurs tâches en même temps. Sur un seul processeur, une seule instruction peut être exécutée à la fois, mais le temps d'exécution de chaque instruction est très court. Le processeur effectue plusieurs tâches du point de vue de l'utilisateur grâce à une rotation rapide. Cette rotation rapide rend le temps de commutation des tâches très court et il semble que plusieurs tâches soient exécutées en même temps. Il s'agit du parallélisme.

Dans les applications pratiques, nous utilisons généralement la technologie parallèle pour gérer des scénarios commerciaux à haute concurrence et haute densité. En tirant parti des caractéristiques des processeurs multicœurs, les tâches sont allouées à plusieurs cœurs pour une exécution simultanée afin d'améliorer l'efficacité de l'exécution. En Golang, la goroutine est appelée un thread léger. Elle est plus légère et efficace qu'un thread, et le démarrage d'une goroutine nécessite très peu de frais généraux. Par conséquent, Golang est naturellement adapté à la mise en œuvre d’opérations parallèles.

2. Parallélisme Goroutine

En golang, nous pouvons implémenter des opérations parallèles via goroutine. Goroutine est un thread léger qui est géré par le système d'exécution Golang et ne consomme pas beaucoup de mémoire comme les threads du système d'exploitation. Par conséquent, nous pouvons démarrer plusieurs goroutines en même temps, réduire le temps d'attente des tâches et améliorer l'exécution du programme. efficacité. Voyons comment démarrer goroutine.

1. Définir goroutine

La façon de définir goroutine dans golang est très simple. Il vous suffit d'ajouter le mot-clé go avant le corps de la fonction qui doit être exécuté indépendamment. Par exemple :

go func() {
    fmt.Println("Hello, goroutine!")
}()

2. Démarrez goroutine

Démarrer goroutine est très simple, il suffit d'appeler la fonction. Par exemple :

func main() {
    go func() {
        fmt.Println("Hello, goroutine!")
    }()
    fmt.Println("Hello, main!")
    time.Sleep(time.Second)
}

Dans le code ci-dessus, nous démarrons une goroutine pour imprimer une phrase, tandis que la fonction principale continue d'imprimer ses propres mots et fait une pause d'1 seconde. Lorsque nous exécuterons le programme à ce moment-là, nous verrons que la fonction principale et la goroutine imprimeront alternativement Hello, main! et Hello, goroutine !, ce qui prouve que les deux fonctions sont exécutées en parallèle dans des goroutines différentes.

3. Channel

Channel (Channel) est un mécanisme de communication inter-thread fourni par golang. Sa fonction est de transférer des données entre les goroutines. Un canal a deux points de terminaison, les extrémités d’envoi et de réception. Nous pouvons créer un canal via le mot-clé make, puis utiliser <- pour transférer des données. Par exemple : make来创建一个通道，然后利用<-来进行数据的传递。例如：

func goroutineFunc(c chan int) {
    c <- 1
}

func main() {
    c := make(chan int)
    go goroutineFunc(c)
    result := <-c
    fmt.Println(result)
}

上面的代码中，我们在启动goroutine的同时也创建了一个通道c，然后在goroutine中用c <- 1向通道中写入1，最后通过result := <-c

func pi(n int) float64 {
    ch := make(chan float64)
    for i := 0; i < n; i++ {
        go func(start, end int) {
            sum := 0.0
            for j := start; j < end; j++ {
                x := (float64(j) + 0.5) / float64(n)
                sum += 4.0 / (1.0 + x*x)
            }
            ch <- sum
        }(i*n/n, (i+1)*n/n)
    }
    result := 0.0
    for i := 0; i < n; i++ {
        result += <-ch
    }
    return result / float64(n)
}

func main() {
    fmt.Println(pi(10000))
}

Dans le code ci-dessus, nous créons un canal c lors du démarrage de la goroutine, puis utilisons c <- 1 pour écrire 1 dans le canal dans la goroutine, et enfin passons result := <-c pour lire les données. Cette méthode peut échanger des données dans différentes goroutines et réaliser des opérations parallèles à grande échelle.

3. Calcul parallèle

Si nous voulons effectuer du calcul parallèle, nous devons attribuer des tâches informatiques à différentes goroutines pour l'exécution et échanger des données via des canaux. Ci-dessous, nous utilisons un exemple de code pour montrer comment utiliser Golang pour implémenter le calcul parallèle.

1. Calcul parallèle de la valeur pi

func MatrixMul(a, b [][]int) [][]int {
    m, n, p := len(a), len(a[0]), len(b[0])
    c := make([][]int, m)
    for i := 0; i < m; i++ {
        c[i] = make([]int, p)
    }

    ch := make(chan int)
    for i := 0; i < m; i++ {
        for j := 0; j < p; j++ {
            go func(x, y int) {
                sum := 0
                for k := 0; k < n; k++ {
                    sum += a[x][k] * b[k][y]
                }
                ch <- sum
            }(i, j)
        }
    }

    for i := 0; i < m; i++ {
        for j := 0; j < p; j++ {
            c[i][j] = <-ch
        }
    }

    return c
}

func main() {
    a := [][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
    b := [][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
    fmt.Println(MatrixMul(a, b))
}

Dans le code ci-dessus, nous créons d'abord un canal ch d'une longueur de n, puis utilisons n goroutines pour effectuer des calculs et écrire les résultats du calcul dans le canal. Enfin, nous lisons la somme de tous les résultats du canal et calculons la valeur π. Grâce au calcul parallèle, nous pouvons augmenter considérablement la vitesse de calcul.

2. Calcul parallèle de la multiplication matricielle

rrreee

Dans le code ci-dessus, nous utilisons la goroutine pour calculer le produit des matrices en parallèle. Attribuez des tâches informatiques aux goroutines, puis échangez des données via des canaux. Enfin, nous lisons tous les résultats du canal et formons une matrice de produits. Grâce au calcul parallèle, nous sommes en mesure d'augmenter la vitesse de calcul et de réduire les coûts informatiques.

Résumé

Cet article présente principalement comment utiliser goroutine pour implémenter le calcul parallèle dans golang, et comment utiliser goroutine et les canaux. Grâce au calcul parallèle, nous pouvons allouer des tâches informatiques à plusieurs goroutines pour améliorer l'efficacité de l'exécution des programmes et sommes adaptés à la gestion de scénarios commerciaux à haute concurrence et haute densité. Les mécanismes de goroutine et de canal intégrés de Golang rendent les opérations parallèles plus faciles et plus efficaces que les autres langages. 🎜

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!