konstruk chan chan menyebabkan kebuntuan

Saya cuba memahami konstruk chan chan 构造，如下所示，我希望 3 个工作子例程处理 10 个作业。每个工作子例程都有自己的通道，在其中接收要处理的“作业”。主 Go 例程通过从通道池中获取通道（因此是 chan chan dalam Go dengan menulis sekeping kecil kod untuk mengagihkan kerja ke saluran kerja.

Tetapi kod ini akan membawa kepada situasi kebuntuan! Saya mencuba beberapa variasi kod ini tetapi mendapat ralat yang sama.

Adakah kerana subrutin pekerja menunggu selama-lamanya untuk membaca kerja daripada salurannya? Atau adakah ia disebabkan oleh sebab lain (mungkin saluran ditutup sebelum waktunya, dsb.)? Saya jelas kehilangan sesuatu dalam pemahaman saya tentang keseluruhan struktur.

Bolehkah seseorang membantu saya memahami masalah ini dan cara menyelesaikannya?

Kod dari taman permainan dan salin di bawah seperti yang diminta.

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

Jawapan betul

Pertama sekali: tidak perlu ada saluran saluran di sini. Untuk mengagihkan kerja kepada berbilang pekerja, anda hanya minta semua pekerja membaca daripada saluran kongsi tunggal. Apabila anda menghantar karya ke saluran, jika ada pekerja yang tersedia, salah seorang daripada mereka akan menerimanya, jika tidak, operasi penghantaran saluran akan disekat sehingga ada pekerja yang tersedia.

Jika anda ingin menggunakan saluran berasingan untuk setiap pekerja, anda masih tidak memerlukan saluran saluran, anda hanya memerlukan sebahagian daripadanya. Setiap pekerja akan mendengar daripada saluran khusus dan anda akan menguruskan sendiri tugasan kerja anda:

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

Terdapat dua masalah dengan kod anda:

1. Anda harus menambah kumpulan menunggu semasa membuat Goroutine, bukan semasa menghantar kerja ke saluran
2. Apabila anda membaca saluran daripada saluran tersebut, saluran tersebut akan dialih keluar daripada kolam. Jadi selepas anda membaca 3 saluran, workerChannel := <-pool akan menyekat kerana tiada saluran lain. Jika anda berkeras untuk menggunakan saluran saluran, anda perlu meletakkannya semula:

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

Dengan cara ini anda boleh menggunakan saluran saluran sebagai baris gilir bulat

1. Tutup saluran dalam pool 不会有任何效果。您必须关闭 pool.

Atas ialah kandungan terperinci konstruk chan chan menyebabkan kebuntuan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!