Le modèle de concurrence de Golang : Comment implémenter facilement la programmation parallèle ?

Le modèle de concurrence de Golang : Comment implémenter facilement la programmation parallèle ?

Introduction :
Dans le domaine des ordinateurs modernes, avec la croissance continue des besoins informatiques, les développeurs sont devenus de plus en plus urgents d'améliorer l'efficacité du fonctionnement des programmes. La programmation simultanée est une façon de répondre à ce besoin. En tant que puissant langage de programmation simultanée, Golang rend la programmation parallèle simple et efficace grâce à son modèle de concurrence unique. Cet article présentera le modèle de concurrence de Golang et comment implémenter facilement la programmation parallèle.

1. Bases du modèle de concurrence Golang
Dans Golang, la programmation simultanée est principalement implémentée via goroutine et canal.

1. goroutine
   Goroutine est un thread léger dans Golang qui peut effectuer des tâches parallèles dans un environnement simultané. Lors de l'écriture d'un programme Golang, nous pouvons utiliser le mot-clé go pour créer une nouvelle goroutine, par exemple :

   func main() {
    go task1()   // 创建goroutine并执行task1
    go task2()   // 创建goroutine并执行task2
    // ...
   }

   Copier après la connexion

   En utilisant goroutine, nous pouvons exécuter plusieurs tâches en parallèle sans bloquer le thread principal, améliorant ainsi l'efficacité d'exécution du programme.

2. channel
   Channel est un pipeline utilisé pour la communication entre les goroutines dans Golang. Nous pouvons envoyer des données d'une goroutine à une autre et les utiliser pour garantir la sécurité de la concurrence. En utilisant des canaux, la synchronisation et le transfert de données entre les goroutines peuvent être réalisés.

Dans Golang, nous pouvons utiliser la fonction make pour créer un canal, par exemple :

ch := make(chan int)   // 创建一个整型channel

Le canal peut lire et écrire des données via l'opérateur <-, par exemple :

ch <- data   // 向channel中写入数据
data := <-ch  // 从channel中读取数据

En utilisant le canal, nous pouvons Réaliser échange de données et coordination entre plusieurs goroutines pour garantir l'exactitude et la cohérence des opérations simultanées.

2. Exemple d'implémentation de programmation parallèle
Ce qui suit utilisera un exemple spécifique pour montrer comment utiliser le modèle de concurrence de Golang pour implémenter la programmation parallèle.

Supposons que nous ayons une tâche fastidieuse qui nécessite de mettre au carré chaque élément dans une tranche entière. Nous pouvons utiliser la programmation parallèle pour diviser la tranche entière en plusieurs sous-tranches, effectuer l'opération carrée en parallèle dans chaque goroutine et enfin fusionner les résultats.

L'exemple de code est le suivant :

package main

import (
    "fmt"
    "sync"
)

func main() {
    data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := parallelSquare(data)
    fmt.Println("结果：", result)
}

func parallelSquare(data []int) []int {
    // 创建等待组，用于等待所有goroutine完成
    var wg sync.WaitGroup

    // 创建一个大小为10的channel，用于接收每个goroutine的计算结果
    ch := make(chan int, 10)

    // 根据CPU核心数量创建对应数量的goroutine
    cpuNum := runtime.NumCPU()
    wg.Add(cpuNum)
    for i := 0; i < cpuNum; i++ {
        go func() {
            defer wg.Done()

            // 每个goroutine对应的子切片
            subData := data[i*len(data)/cpuNum : (i+1)*len(data)/cpuNum]
            for _, num := range subData {
                square := num * num
                ch <- square
            }
        }()
    }

    // 等待所有goroutine完成任务
    go func() {
        wg.Wait()
        close(ch)
    }()

    // 从channel中读取结果，并将其合并为一个整型切片
    var result []int
    for square := range ch {
        result = append(result, square)
    }

    return result
}

Dans le code ci-dessus, nous implémentons des opérations de carrés parallèles via la fonction parallelSquare. Dans un premier temps, nous avons créé un groupe d'attente et un canal de taille 10 pour recevoir les résultats des calculs de la goroutine. Ensuite, créez un nombre correspondant de goroutines en fonction du nombre de cœurs de processeur, et chaque goroutine correspond à une sous-tranche à traiter. Dans chaque goroutine, nous mettons chaque élément au carré et envoyons le résultat au canal. Enfin, nous utilisons une goroutine distincte pour attendre que toutes les goroutines terminent leurs tâches et ferment le canal. La goroutine principale lit les résultats du canal, les combine en une tranche entière et la renvoie.

Résumé : 
Grâce au modèle de concurrence de Golang, nous pouvons facilement mettre en œuvre une programmation parallèle et améliorer l'efficacité de fonctionnement du programme. En utilisant goroutine et canal, nous pouvons facilement créer des tâches simultanées et effectuer un échange de données et une synchronisation entre les tâches. J'espère que cet article sera utile pour comprendre le modèle de concurrence de Golang et comment implémenter la programmation parallèle.

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!