Guide de programmation simultanée : Exploration du parallélisme dans la bibliothèque standard Golang

Guide de programmation simultanée dans la bibliothèque standard de Golang

Introduction :
La programmation simultanée est un moyen important pour résoudre les problèmes de performances des programmes et parvenir à une utilisation efficace des ressources informatiques. Le langage de programmation Golang fournit une multitude d’outils et de méthodes de programmation simultanée. Cet article présentera certaines techniques de programmation simultanée courantes dans la bibliothèque standard Golang et illustrera leur utilisation et leurs précautions à travers des exemples de code spécifiques.

1. Goroutine (Coroutine)
   Goroutine est un fil de discussion léger en Golang, lancé par le mot-clé Go. Grâce à Goroutine, nous pouvons exécuter plusieurs tâches en même temps dans le programme pour obtenir des effets d'exécution à haute concurrence. Ce qui suit est un exemple simple de Goroutine :

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 0; i < 5; i++ {
        fmt.Printf("%d ", i)
        time.Sleep(time.Millisecond * 500)
    }
}

func printLetters() {
    for i := 'A'; i < 'F'; i++ {
        fmt.Printf("%c ", i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    go printNumbers()    // 启动一个Goroutine，打印数字
    go printLetters()    // 启动另一个Goroutine，打印字母

    time.Sleep(time.Second * 3)    // 等待两个Goroutine执行完毕
    fmt.Println("Done")
}

Dans le code ci-dessus, nous avons défini deux fonctions printNumbers et printLetters respectivement, et avons passé go Le mot-clé code> les démarre respectivement comme deux Goroutines. Utilisez la fonction time.Sleep pour attendre que les deux Goroutines terminent l'exécution. Vous pouvez voir que les chiffres et les lettres sont affichés alternativement dans les résultats de sortie. printNumbers和printLetters两个函数，并通过go关键字将它们分别启动为两个Goroutine。通过time.Sleep函数等待两个Goroutine执行完毕，可以看到输出结果中数字和字母是交替输出的。

2. Channel（通道）
   在Golang中，Goroutine之间的通信使用Channel（通道）来完成。Channel是一种类型安全的队列，用于在Goroutine之间传递数据。下面是一个简单的Channel示例：

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        fmt.Printf("Worker %d started job %d
", id, job)
        time.Sleep(time.Second)
        fmt.Printf("Worker %d finished job %d
", id, job)
        results <- job * 2
    }
}

func main() {
    numJobs := 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    numWorkers := 3
    for w := 1; w <= numWorkers; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= numJobs; a++ {
        result := <-results
        fmt.Println("Result:", result)
    }
}

在上述代码中，我们定义了worker函数，该函数用于接收jobs通道传入的数字，并进行相应的处理，结果通过results通道返回。在主函数中，我们分别创建了jobs和results两个通道，并将jobs通道传递给三个Goroutine执行。然后，通过for循环向jobs通道发送5个作业，并关闭通道。最后，通过for循环接收results通道的返回结果并输出。

3. WaitGroup（等待组）
   在并发编程中，经常需要等待多个Goroutine的全部执行完成后再进行下一步的操作。Golang中的sync包提供了WaitGroup类型来实现这个功能。下面是一个使用WaitGroup的示例：

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting
", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done
", id)
}

func main() {
    var wg sync.WaitGroup

    numWorkers := 3
    wg.Add(numWorkers)
    for w := 1; w <= numWorkers; w++ {
        go worker(w, &wg)
    }

    wg.Wait()
    fmt.Println("All workers done")
}

在上述代码中，我们定义了worker函数，该函数接收一个WaitGroup参数，执行相应的任务，并在任务执行完成后通过Done方法通知WaitGroup。在主函数中，我们创建了一个WaitGroup变量，并通过Add方法指定需要等待的Goroutine数量。然后，使用go关键字启动相应数量的Goroutine，并将WaitGroup指针传递给每个Goroutine。最后，通过Wait

Channel

Dans Golang, la communication entre les Goroutines s'effectue à l'aide de Channel. Channel est une file d'attente de type sécurisé utilisée pour transmettre des données entre Goroutines. Voici un exemple simple de canal :


rrreee🎜Dans le code ci-dessus, nous définissons la fonction worker, qui est utilisée pour recevoir les numéros transmis par le canal jobs et les traiter en conséquence. est transmis. Le canal Résultats est renvoyé. Dans la fonction principale, nous avons créé deux canaux, respectivement les tâches et les résultats, et avons transmis le canal des tâches à trois Goroutines pour exécution. Ensuite, envoyez 5 tâches au canal jobs via la boucle for et fermez le canal. Enfin, le résultat de retour du canal de résultats est reçu via la boucle for et la sortie. 🎜
🎜WaitGroup (waiting group)🎜En programmation simultanée, il est souvent nécessaire d'attendre la fin de toutes les exécutions de plusieurs Goroutines avant de passer à l'étape suivante. Le package sync dans Golang fournit le type WaitGroup pour implémenter cette fonction. Voici un exemple d'utilisation de WaitGroup : 🎜🎜rrreee🎜Dans le code ci-dessus, nous définissons la fonction worker, qui reçoit un paramètre WaitGroup, exécute la tâche correspondante et passe Terminé informe WaitGroup. Dans la fonction principale, nous créons une variable WaitGroup et spécifions le nombre de Goroutines à attendre via la méthode Add. Ensuite, utilisez le mot-clé go pour démarrer le nombre correspondant de Goroutines et transmettez le pointeur WaitGroup à chaque Goroutine. Enfin, attendez la fin de toutes les exécutions de Goroutine via la méthode Wait. 🎜🎜Résumé : 🎜Grâce aux outils et méthodes de programmation simultanée fournis dans la bibliothèque standard Golang, nous pouvons facilement implémenter des programmes à haute concurrence. Cet article présente les techniques de programmation simultanée courantes telles que Goroutine, Channel et WaitGroup, et les illustre avec des exemples de code spécifiques. J'espère que les lecteurs pourront mieux maîtriser les compétences de programmation simultanée dans Golang et améliorer les performances et l'efficacité opérationnelle du programme en étudiant cet article. 🎜

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!