Programmation simultanée efficace : utilisation de Go WaitGroup et des pools de coroutines

Programmation simultanée efficace : utilisation de Go WaitGroup et Coroutine Pool

Introduction :
Dans les systèmes informatiques modernes, la programmation simultanée devient de plus en plus importante. La programmation simultanée peut maximiser l'utilisation des performances du processeur multicœur et améliorer l'efficacité de l'exécution du programme. Cependant, la programmation simultanée est également confrontée à des défis, tels que la gestion de la synchronisation et de la gestion des tâches simultanées. Dans cet article, nous présenterons comment utiliser WaitGroup et le pool de coroutines dans le langage Go pour obtenir une programmation simultanée efficace et fournirons des exemples de code spécifiques.

1. Utilisation de WaitGroup : 
Le langage Go fournit un type WaitGroup très utile, qui peut être utilisé pour attendre qu'un groupe de coroutines termine son exécution. Voici un exemple simple qui montre comment utiliser WaitGroup pour réaliser la synchronisation de tâches simultanées :

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()

    fmt.Printf("Worker %d starting
", id)

    // 模拟耗时的任务
    for i := 0; i < 5; i++ {
        fmt.Printf("Worker %d: %d
", id, i)
    }

    fmt.Printf("Worker %d done
", id)
}

func main() {
    var wg sync.WaitGroup

    // 启动5个协程
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    // 等待所有协程执行完毕
    wg.Wait()
}

Dans le code ci-dessus, nous définissons une fonction de travail pour simuler des tâches chronophages. Nous informons le WaitGroup que la tâche a été terminée en passant un pointeur vers le WaitGroup. Dans la fonction principale, nous avons démarré 5 coroutines et notifié à WaitGroup d'augmenter le nombre de tâches en attente en appelant la méthode wg.Add(1). Enfin, nous appelons la méthode wg.Wait() pour bloquer la coroutine principale jusqu'à ce que toutes les tâches soient terminées. wg.Add(1)方法来通知WaitGroup等待的任务数量加一。最后，我们调用wg.Wait()方法来阻塞主协程，直到所有的任务都完成。

二、协程池的使用：
Go语言还提供了协程池的实现，用于限制并发的数量，防止同时运行太多的协程。协程池可以帮助我们平衡系统的资源，并避免资源浪费。下面是一个示例，展示了如何使用协程池来执行任务：

package main

import (
    "fmt"
    "sync"
)

type Pool struct {
    workers chan struct{}
    wg      sync.WaitGroup
}

func NewPool(size int) *Pool {
    return &Pool{
        workers: make(chan struct{}, size),
    }
}

func (p *Pool) AddTask(task func()) {
    p.workers <- struct{}{}
    p.wg.Add(1)

    go func() {
        task()
        <-p.workers
        p.wg.Done()
    }()
}

func (p *Pool) Wait() {
    p.wg.Wait()
}

func main() {
    pool := NewPool(3)

    // 添加10个任务到协程池
    for i := 0; i < 10; i++ {
        taskID := i
        pool.AddTask(func() {
            fmt.Printf("Task %d is running
", taskID)
        })
    }

    // 等待所有任务完成
    pool.Wait()
}

在上述代码中，我们定义了一个Pool结构体，其中包含一个用于限制协程数量的workers通道和一个WaitGroup用于等待所有任务完成。我们通过调用p.workers <- struct{}{}往通道中写入一个空结构体，表示有一个协程正在执行任务；通过<-p.workers从通道中取出一个空结构体，表示一个协程执行完了任务。在AddTask方法中，我们将任务添加到协程池中，并在任务执行完成后从通道中取出一个空结构体。最后，调用pool.Wait()

2. L'utilisation du pool de coroutines :

Le langage Go fournit également la mise en œuvre du pool de coroutines, qui est utilisé pour limiter le nombre de simultanéités et empêcher trop de coroutines de s'exécuter en même temps. Le pool de coroutines peut nous aider à équilibrer les ressources du système et à éviter le gaspillage de ressources. Voici un exemple qui montre comment utiliser un pool de coroutines pour effectuer des tâches :
rrreee

Dans le code ci-dessus, nous définissons une structure Pool qui contient un canal de travail pour limiter le nombre de coroutines et un WaitGroup pour attendre toutes les tâches terminées. Nous écrivons une structure vide dans le canal en appelant p.workers <- struct{}{}, indiquant qu'une coroutine exécute la tâche en appelant <-p.workers Supprime une structure vide du canal, indiquant qu'une coroutine a terminé sa tâche. Dans la méthode AddTask, nous ajoutons la tâche au pool de coroutines et supprimons une structure vide du canal une fois l'exécution de la tâche terminée. Enfin, appelez la méthode pool.Wait() pour attendre que toutes les tâches soient terminées. 🎜🎜Conclusion : 🎜En utilisant WaitGroup et le pool de coroutines, nous pouvons facilement réaliser une programmation simultanée efficace. WaitGroup nous aide à synchroniser l'exécution des tâches simultanées, tandis que le pool de coroutines limite le nombre de simultanéités et améliore l'utilisation des ressources système. Dans les applications réelles, nous pouvons ajuster la taille du pool de coroutines en fonction des besoins pour utiliser pleinement les performances de l'ordinateur. 🎜

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!