Chan-Chan-Konstrukt verursacht Deadlock

Ich versuche, das chan chan 构造，如下所示，我希望 3 个工作子例程处理 10 个作业。每个工作子例程都有自己的通道，在其中接收要处理的“作业”。主 Go 例程通过从通道池中获取通道（因此是 chan chan-Konstrukt in Go zu verstehen, indem ich einen kleinen Codeabschnitt schreibe, um Jobs an Arbeitskanäle zu verteilen.

Aber dieser Code führt zu einer Deadlock-Situation! Ich habe einige Variationen dieses Codes ausprobiert, aber den gleichen Fehler erhalten.

Liegt es daran, dass die Worker-Subroutine ewig darauf wartet, den Job aus ihrem Kanal zu lesen? Oder liegt es an anderen Gründen (vielleicht wird der Kanal vorzeitig geschlossen usw.)? Mir fehlt offensichtlich etwas in meinem Verständnis der gesamten Struktur.

Kann mir jemand helfen, dieses Problem zu verstehen und es zu lösen?

Code vom Spielplatz und wie gewünscht unten kopiert.

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")
}

Richtige Antwort

Zuallererst: Es ist hier kein Kanal von Kanälen nötig. Um die Arbeit auf mehrere Mitarbeiter zu verteilen, lassen Sie einfach alle Mitarbeiter von einem einzigen freigegebenen Kanal lesen. Wenn Sie eine Arbeit an einen Kanal senden und Arbeiter verfügbar sind, wird einer von ihnen sie empfangen. Andernfalls wird der Kanalsendevorgang blockiert, bis ein Arbeiter verfügbar ist.

Wenn Sie für jeden Mitarbeiter separate Kanäle verwenden möchten, benötigen Sie trotzdem keinen Kanal von Kanälen, sondern nur einen Teil davon. Jeder Mitarbeiter hört über einen speziellen Kanal zu und Sie verwalten Ihre Arbeitsaufträge selbst:

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()

Es gibt zwei Probleme mit Ihrem Code:

1. Sie sollten beim Erstellen der Goroutine zur Wartegruppe hinzufügen, nicht beim Senden des Jobs an den Kanal
2. Wenn Sie einen Kanal aus dem Kanal lesen, wird der Kanal aus dem Pool entfernt. Nachdem Sie also 3 Kanäle gelesen haben, wird workerChannel := <-pool blockiert, da keine anderen Kanäle vorhanden sind. Wenn Sie darauf bestehen, den Kanal des Kanals zu verwenden, müssen Sie ihn zurücksetzen:

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

Auf diese Weise können Sie den Kanal des Kanals als kreisförmige Warteschlange nutzen

1. Schließe den Kanal in pool 不会有任何效果。您必须关闭 pool.

Das obige ist der detaillierte Inhalt vonChan-Chan-Konstrukt verursacht Deadlock. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!