Comment implémenter la programmation simultanée à l'aide des fonctions Golang

Les fonctions du langage Go implémentent la programmation simultanée en créant des coroutines et en utilisant des canaux. Les coroutines sont des threads légers créés avec le mot-clé go. Un canal est un canal permettant de transférer des données entre des coroutines. La coroutine productrice utilise l'opérateur L'exemple suivant montre un cas pratique de traitement parallèle de données, dans lequel la fonction de travail met au carré la valeur d'entrée et implémente la communication inter-coroutine via le canal de travail et le canal de résultat.

Les fonctions du langage Go implémentent la programmation simultanée

Dans le langage Go, les fonctions fournissent des outils puissants pour implémenter la programmation simultanée. En créant et en gérant des fonctions simultanées, nous pouvons facilement écrire des applications efficaces et évolutives.

Coroutine

Coroutine en langage Go est un thread léger qui partage l'espace mémoire du programme principal. Le coût de commutation entre les coroutines est faible, ce qui les rend idéales pour exécuter des tâches parallèles.

Pour créer une coroutine, vous pouvez utiliser le mot-clé go : go 关键字：

go func() {
  // 并发执行的代码
}

每个协程都会并行执行，并且不受主程序或其他协程的影响。

通道

通道是在协程之间传递数据的管道。数据通过 chan 关键字声明，例如：

ch := make(chan int)

生产者协程可以使用 操作符从通道中发送数据：

ch <- 1

消费者协程可以使用 -> 操作符从通道中接收数据：

val := <-ch

实战案例：并行处理数据

以下示例展示了如何使用函数实现并行处理数据：

package main

import (
    "fmt"
    "sync"
)

// 工作函数
func worker(in <-chan int, out chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    
    for v := range in {
        v *= v
        out <- v
    }
}

func main() {
    // 创建工作通道和结果通道
    in := make(chan int)
    out := make(chan int)
    
    // 创建工作池
    var wg sync.WaitGroup
    for i := 0; i < 4; i++ {
        wg.Add(1)
        go worker(in, out, &wg)
    }
    
    // 向工作通道中发送数据
    for i := 0; i < 1000; i++ {
        in <- i
    }
    
    // 关闭工作通道
    close(in)
    
    // 从结果通道中接收数据
    for v := range out {
        fmt.Printf("%d ", v)
    }
    
    // 等待所有工作完成
    wg.Wait()
}

在这个案例中，workerrrreee

Chaque coroutine s'exécutera en parallèle et n'est pas affectée par le programme principal ou les autres coroutines. 🎜🎜Channels🎜🎜Les canaux sont des canaux qui transfèrent des données entre coroutines. Les données sont déclarées via le mot-clé chan, par exemple : 🎜rrreee🎜La coroutine du producteur peut utiliser l'opérateur pour envoyer des données depuis le canal : 🎜rrreee🎜La coroutine du consommateur Vous peut utiliser l'opérateur -> pour recevoir des données d'un canal : 🎜rrreee🎜Un cas pratique : traiter des données en parallèle🎜🎜L'exemple suivant montre comment utiliser des fonctions pour traiter des données en parallèle : 🎜rrreee 🎜Dans ce cas, la fonction worker traite les données, en mettant au carré chaque valeur d'entrée. Nous créons un pool de travailleurs contenant quatre coroutines. Le programme principal envoie des données au canal de travail, tandis que la coroutine reçoit les données du canal et traite les tâches en parallèle. Enfin, le programme principal reçoit les données traitées du canal de résultat. 🎜

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!