Application de la fermeture de la fonction Golang dans la programmation simultanée

Les fermetures sont des fonctionnalités de Go qui permettent aux fonctions d'accéder à des variables externes et sont utiles en programmation simultanée. Grâce aux fermetures, les coroutines peuvent partager des données et transmettre des valeurs en toute sécurité. Les applications courantes des fermetures dans la programmation simultanée incluent le partage de données sans nécessiter de mécanismes de synchronisation. Transmettez les valeurs entre les coroutines, même si la valeur n'est pas disponible jusqu'à la fermeture de la fermeture. Annulez une coroutine en stockant un canal indiquant l’opération d’annulation.

Application des fermetures de fonctions du langage Go dans la programmation simultanée

Les fermetures sont une fonctionnalité puissante du langage Go, qui permet aux fonctions d'accéder à des variables en dehors de leur portée. Ce mécanisme est très utile en programmation concurrente car il nous permet de partager des données en toute sécurité et de transmettre des valeurs entre coroutines.

Principe de base

Une fermeture fait référence à une fonction et à l'ensemble de toutes les variables dans sa portée. En Go, une fonction peut renvoyer un pointeur vers une autre fonction (fermeture). Cette fermeture peut accéder à toutes les variables dans la portée de sa fonction parent, même si la fonction parent est revenue.

Par exemple, le code suivant montre une fermeture simple :

func outer(x int) func() int {
    // x 的值在这个闭包内部可用
    return func() int {
        return x
    }
}

La fonction externe renvoie une fermeture qui accède et renvoie la variable x</code sur la valeur du code d'appel de la fonction de retour> . <code>outer 函数返回了一个闭包，该闭包访问并在返回函数调用时返回变量 x 的值。

并发编程中的应用

闭包在并发编程中非常有用，因为它允许在协程之间安全地共享和修改数据。以下是一些常见的用例：

• 共享数据：闭包可以在多个协程之间共享数据，而无需使用互斥锁或其他同步机制。
• 传值：闭包可以在协程之间传值，即使这些值在闭包闭合后才可用。
• 取消操作：闭包可以存储一个通道，该通道指示何时取消操作。这允许我们优雅地退出协程，并清理任何已分配的资源。

实战案例

考虑以下代码示例，它演示了闭包在并发编程中的使用：

package main

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

func main() {

    // 创建一个要并发执行的任务列表
    tasks := []func(){
        func() { fmt.Println("Task 1") },
        func() { fmt.Println("Task 2") },
        func() { fmt.Println("Task 3") },
    }

    // 创建一个等待组以跟踪并发的任务
    var wg sync.WaitGroup
    wg.Add(len(tasks))

    // 创建一个通道来取消操作
    cancel := make(chan struct{})

    // 为每个任务创建一个闭包
    for _, task := range tasks {
        go func(task func()) {
            defer wg.Done()
            select {
            case <-cancel:
                // 如果收到取消信号，则退出协程
                return
            default:
                // 如果没有收到取消信号，则执行任务
                task()
            }
        }(task)
    }

    // 等待所有任务完成
    wg.Wait()
    fmt.Println("All tasks completed")

    // 发送取消信号以取消任何正在运行的协程
    close(cancel)
}

用法：

• tasks 列表包含要并发执行的任务。
• wg 跟踪并发任务的进度。
• cancel 通道用于向协程发送取消信号。
• 每个任务都通过闭包封装在自己的协程中。该闭包可以访问 cancel 通道，以便在接收到取消信号时退出。
• 主协程使用 wg.Wait() 等待所有任务完成。
• 一旦所有任务完成，主协程发送 cancel 信号以取消任何剩余的协程。

在这个示例中，闭包被用来在协程之间安全地共享 cancel

Applications en programmation simultanée🎜🎜Les fermetures sont très utiles en programmation simultanée car elles permettent de partager et de modifier les données en toute sécurité entre les coroutines. Voici quelques cas d'utilisation courants : 🎜

• Données partagées : Les fermetures peuvent partager des données entre plusieurs coroutines sans utiliser de mutex ou d'autres mécanismes de synchronisation.
• Passage par valeur : Les fermetures peuvent transmettre des valeurs entre coroutines, même si ces valeurs ne sont pas disponibles tant que la fermeture n'est pas fermée.
• Annuler l'opération : Une fermeture peut stocker un canal qui indique quand l'opération est annulée. Cela nous permet de quitter gracieusement la coroutine et de nettoyer toutes les ressources allouées.

🎜Exemple pratique🎜🎜Considérez l'exemple de code suivant, qui démontre l'utilisation des fermetures dans la programmation concurrente : 🎜rrreee🎜Utilisation : 🎜

• tâches contient les tâches à exécuter simultanément.
• wg Suit la progression des tâches simultanées.
• Le canal cancel est utilisé pour envoyer des signaux d'annulation aux coroutines.
• Chaque tâche est encapsulée dans sa propre coroutine grâce à la fermeture. La fermeture a accès au canal cancel pour sortir lorsqu'un signal d'annulation est reçu.
• La coroutine principale utilise wg.Wait() pour attendre que toutes les tâches soient terminées.
• Une fois toutes les tâches terminées, la coroutine principale envoie le signal cancel pour annuler toutes les coroutines restantes.

🎜Dans cet exemple, les fermetures sont utilisées pour partager en toute sécurité le canal cancel entre les coroutines, nous permettant d'annuler l'opération en cas de besoin. 🎜

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!