Collaboration entre la fermeture de la fonction Golang et goroutine

Les fermetures de fonctions et les Goroutines collaborent dans le langage Go pour créer des programmes simultanés et efficaces : les fermetures de fonctions permettent aux fonctions d'accéder à des variables externes même une fois l'exécution de la fonction terminée. Goroutine est une coroutine légère qui peut être exécutée en parallèle. Utilisez les fermetures de fonctions avec Goroutines pour fournir un mécanisme puissant d'exécution simultanée. Exemple : traitez les éléments du tableau en parallèle, créez Goroutine via la fermeture de fonction, calculez le carré de chaque élément, puis accumulez le résultat via des canaux.

Collaboration des fermetures de fonctions et des Goroutines dans le langage Go

Dans le langage Go, les fermetures de fonctions et les Goroutines sont deux éléments puissants qui fonctionnent ensemble pour créer des programmes simultanés et efficaces. Cet article explique comment utiliser les fermetures fonctionnelles et la collaboration Goroutine pour améliorer les performances et la maintenabilité de votre application.

Fermeture de fonction

Une fermeture de fonction est une fonction qui peut accéder à des variables en dehors de sa portée de définition. Dans Go, vous pouvez créer une fermeture de fonction en créant une fonction anonyme et en la stockant dans une variable.

Par exemple :

func createCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

La fonction ci-dessus createCounter crée une fermeture de fonction qui renvoie une fonction anonyme. Cette fonction anonyme peut accéder et modifier la variable externe count même après la fin de la fonction createCounter. createCounter 创建了一个函数闭包，它返回一个匿名函数。此匿名函数可以访问并修改外部变量 count，即使在 createCounter 函数执行完毕后也是如此。

Goroutine

Goroutine 是 Go 语言中的轻量级并发执行单元。它们本质上是协程，可以在不阻塞主线程的情况下并行执行。Goroutine 可以通过 go 关键字创建。

例如：

go func() {
    for i := 0; i < 10; i++ {
        // 在 Goroutine 中执行的操作
    }
}

将 Goroutine 与函数闭包结合使用，可以为并发执行创建强大的机制。

实战案例

以下是一个实战案例，展示函数闭包和 Goroutine 协作的用法：

// 并行处理数组元素
func parallelSum(arr []int) int {
    // 创建一个通道来接收各个 Goroutine 的结果
    resCh := make(chan int)

    // 遍历数组元素并为每个元素创建一个 Goroutine
    for _, num := range arr {
        go func(n int) {
            // 计算元素的平方，并将其发送到通道
            resCh <- n * n
        }(num)
    }

    // 初始化 sum 变量并等待各个 Goroutine 完成
    sum := 0
    for i := 0; i < len(arr); i++ {
        sum += <-resCh
    }

    // 返回平方元素的总和
    return sum
}

在上面的示例中，parallelSum

Goroutine

Goroutine est une unité d'exécution simultanée légère dans le langage Go. Ce sont essentiellement des coroutines et peuvent être exécutées en parallèle sans bloquer le thread principal. Les goroutines peuvent être créées à l'aide du mot-clé go. 🎜🎜Exemple : 🎜rrreee🎜La combinaison de Goroutines avec des fermetures de fonctions crée un mécanisme puissant pour l'exécution simultanée. 🎜🎜Cas pratique🎜🎜Ce qui suit est un cas pratique montrant l'utilisation des fermetures de fonctions et la collaboration Goroutine : 🎜rrreee🎜Dans l'exemple ci-dessus, la fonction parallelSum prend un tableau d'entiers et les calcule en parallèle. Le carré de l'élément. La fermeture de fonction est utilisée pour créer un Goroutine qui calcule le carré d'un seul élément et l'envoie au canal. La goroutine principale attend que toutes les goroutines terminent et accumulent les résultats, puis renvoie la somme finale. 🎜🎜En tirant parti des fermetures de fonctions et des Goroutines, nous sommes en mesure d'effectuer des calculs parallèles rapidement et efficacement sans bloquer le thread principal. Cela améliore considérablement les performances et la réactivité du code. 🎜

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!