Comment résoudre le problème de l’expansion dynamique des tâches simultanées en langage Go ?

Comment résoudre le problème de l'expansion dynamique des tâches simultanées en langage Go ?

Lorsqu'un grand nombre de tâches simultanées doivent être traitées, nous devrons peut-être ajuster dynamiquement le nombre de goroutines simultanées pour obtenir un traitement efficace des tâches. Dans le langage Go, vous pouvez utiliser goroutine et canal pour implémenter une programmation simultanée. En ajustant le nombre de goroutines, vous pouvez contrôler efficacement l'exécution de tâches simultanées.

Afin de résoudre le problème de l'expansion dynamique des tâches simultanées, nous pouvons utiliser un pool de goroutines pour gérer le nombre de goroutines simultanées et utiliser des canaux pour distribuer les tâches et collecter les résultats. Voici un exemple de code :

package main

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

type Pool struct {
    queue chan Job
    wg    sync.WaitGroup
}

type Job struct {
    id     int
    result string
}

func NewPool(maxWorkers int) *Pool {
    pool := &Pool{
        queue: make(chan Job),
    }

    for i := 0; i < maxWorkers; i++ {
        go pool.worker(i)
    }

    return pool
}

func (p *Pool) worker(id int) {
    for job := range p.queue {
        fmt.Printf("Worker %d processing job %d
", id, job.id)
        time.Sleep(time.Second) // 模拟任务耗时
        job.result = fmt.Sprintf("Job %d processed by worker %d", job.id, id)
        p.wg.Done()
    }
}

func (p *Pool) AddJob(job Job) {
    p.wg.Add(1)
    p.queue <- job
}

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

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

    for i := 1; i <= 10; i++ {
        job := Job{id: i}
        pool.AddJob(job)
    }

    pool.Wait()
}

Dans l'exemple de code ci-dessus, nous définissons une structure Pool pour gérer le pool de goroutines, qui contient un canal pour stocker les tâches et un canal pour attendre tout sync.WaitGroup lorsque la tâche est terminée. Pool结构体来管理goroutine池，其中包含一个用于存放任务的channel和一个用于等待所有任务完成的sync.WaitGroup。

NewPool函数用于创建一个新的goroutine池，其中会根据指定的maxWorkers参数创建对应数量的goroutine，并调用worker函数进行任务的处理。

worker函数为每个goroutine的主体函数，它通过从任务channel中获取任务，并处理任务。在处理任务之前，可以根据具体需求进行一些预处理或其他操作。任务处理完成后，将结果赋值给job.result字段，并通过sync.WaitGroup的Done方法来通知任务完成。

AddJob方法用于添加新的任务到任务channel中，它会通过sync.WaitGroup的Add方法增加等待的任务数量，并将任务放入队列中。

Wait方法用于等待所有任务完成，它会调用sync.WaitGroup的Wait方法来阻塞主线程，直到所有任务都被完成。

最后，在main函数中，我们创建了一个大小为3的goroutine池，并添加了10个任务。通过调整maxWorkers

La fonction NewPool est utilisée pour créer un nouveau pool de goroutines, qui créera un nombre correspondant de goroutines en fonction du paramètre maxWorkers spécifié et appellera worker code> La fonction effectue le traitement des tâches. <p></p>La fonction <code>worker est la fonction principale de chaque goroutine. Elle obtient les tâches du canal de tâches et traite les tâches. Avant de traiter la tâche, certains prétraitements ou autres opérations peuvent être effectués en fonction de besoins spécifiques. Une fois le traitement de la tâche terminé, attribuez le résultat au champ job.result et notifiez l'achèvement de la tâche via la méthode Done de sync.WaitGroup. 🎜🎜La méthode AddJob est utilisée pour ajouter de nouvelles tâches au canal de tâches. Elle augmentera le nombre de tâches en attente via la méthode Add de sync.WaitGroup<.> et place la tâche dans la file d'attente. 🎜🎜La méthode <code>Wait est utilisée pour attendre que toutes les tâches soient terminées. Elle appellera la méthode Wait de sync.WaitGroup pour bloquer le. fil principal jusqu'à ce que toutes les tâches soient terminées. 🎜🎜Enfin, dans la fonction main, nous avons créé un pool de goroutines de taille 3 et ajouté 10 tâches. En ajustant la valeur du paramètre maxWorkers, nous pouvons ajuster dynamiquement le nombre de goroutines simultanées. 🎜🎜Avec l'exemple de code ci-dessus, nous pouvons facilement résoudre le problème de l'expansion dynamique des tâches simultanées. En contrôlant raisonnablement le nombre de goroutines simultanées, nous pouvons utiliser le mécanisme de concurrence du langage Go pour obtenir un traitement efficace des tâches. 🎜

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!