La construction Chan Chan provoque une impasse

Contenu de la question

J'essaie de comprendre la construction chan chan 构造，如下所示，我希望 3 个工作子例程处理 10 个作业。每个工作子例程都有自己的通道，在其中接收要处理的“作业”。主 Go 例程通过从通道池中获取通道（因此是 chan chan dans Go en écrivant un petit morceau de code pour distribuer les tâches aux canaux de travail.

Mais ce code mènera à une situation de blocage ! J'ai essayé quelques variantes de ce code mais j'ai eu la même erreur.

Est-ce parce que le sous-programme de travail attend indéfiniment de lire le travail depuis son canal ? Ou est-ce dû à d'autres raisons (peut-être que la chaîne est fermée prématurément, etc.) ? Il me manque évidemment quelque chose dans ma compréhension de l'ensemble de la structure.

Quelqu'un peut-il m'aider à comprendre ce problème et comment le résoudre ?

Code du terrain de jeu et copié ci-dessous comme demandé.

package main

import (
    "fmt"
    "sync"
)

type Job struct {
    ID int
}

func worker(id int, jobs <-chan Job, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job.ID)
    }
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    numWorkers := 3
    maxJobs := 10
    var wg sync.WaitGroup
    // Create the pool of worker channels
    pool := make(chan chan Job, numWorkers)

    for i := 0; i < numWorkers; i++ {
        workerChan := make(chan Job) // Create a new channel for each worker
        pool <- workerChan           // Add the worker channel to the pool
        go worker(i, workerChan, &wg)
    }
    defer close(pool)
    // Create jobs and distribute them to workers
    for i := 0; i < maxJobs; i++ {
        job := Job{ID: i}
        wg.Add(1)
        workerChan := <-pool
        workerChan <- job
    }

    // Wait for all workers to complete
    wg.Wait()
    fmt.Println("All jobs are processed")
}

Bonne réponse

Tout d'abord : il n'y a pas besoin d'une chaîne de chaînes ici. Pour distribuer le travail à plusieurs travailleurs, il vous suffit de demander à tous les travailleurs de lire à partir d'un seul canal partagé. Lorsque vous envoyez un travail à un canal, s'il y a des travailleurs disponibles, l'un d'entre eux le recevra, sinon l'opération d'envoi du canal sera bloquée jusqu'à ce qu'il y ait un travailleur disponible.

Si vous souhaitez utiliser des canaux séparés pour chaque travailleur, vous n'avez toujours pas besoin d'un canal de canaux, vous avez juste besoin d'une partie d'entre eux. Chaque intervenant écoutera depuis un canal dédié et vous gérerez vous-même vos missions de travail :

numWorkers := 3
maxJobs := 10
var wg sync.WaitGroup
pool := make([]chan Job, numWorkers)
for i := 0; i < numWorkers; i++ {
    pool[i] = make(chan Job)
    wg.Add(1)
    go worker(i, pool[i], &wg)
}
for i := 0; i < maxJobs; i++ {
   job := Job{ID: i}
   pool[i%len(pool)] <- job
}
for _,c:=range pool {
   close(c)
}
wg.Wait()

Il y a deux problèmes avec votre code :

1. Vous devez ajouter au groupe d'attente lors de la création de la Goroutine, pas lors de l'envoi du travail à la chaîne
2. Lorsque vous lisez une chaîne de la chaîne, la chaîne sera supprimée du pool. Ainsi, après avoir lu 3 chaînes, workerChannel := <-pool sera bloqué car il n'y a pas d'autres chaînes. Si vous insistez pour utiliser le canal de la chaîne, vous devez le remettre :

workerChan := <-pool
 workerChan <- job
 pool<-workerChan

De cette façon, vous pouvez utiliser la chaîne de la chaîne comme une file d'attente circulaire

1. Fermez la chaîne dans pool 不会有任何效果。您必须关闭 pool.

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!