深入理解Go语言并发：避免Goroutine与Channel死锁的实践指南

package main

import (
    "fmt"
    "time"
)

type entry struct {
    name string
}

type myQueue struct {
    pool        []*entry
    maxConcurrent int
}

// process 函数：工作Goroutine，从队列中读取并处理任务
func process(queue chan *entry, waiters chan bool) {
    for {
        entry, ok := <-queue // 尝试从queue中读取数据
        if ok == false {     // 如果channel已关闭且无数据，ok为false
            break
        }
        fmt.Printf("worker: processing %s\n", entry.name)
        entry.name = "processed_" + entry.name // 模拟处理
        time.Sleep(100 * time.Millisecond) // 模拟耗时操作
    }
    fmt.Println("worker finished")
    waiters <- true // 通知主Goroutine此工作Goroutine已完成
}

// fillQueue 函数：填充任务队列并启动工作Goroutine
func fillQueue(q *myQueue) {
    queue := make(chan *entry, len(q.pool)) // 创建任务队列channel
    for _, entry := range q.pool {
        fmt.Println("push entry:", entry.name)
        queue <- entry // 将任务推入队列
    }
    fmt.Printf("entry cap: %d\n", cap(queue))

    var totalThreads int
    if q.maxConcurrent <= len(q.pool) {
        totalThreads = q.maxConcurrent
    } else {
        totalThreads = len(q.pool)
    }
    waiters := make(chan bool, totalThreads) // 创建等待通知channel
    fmt.Printf("waiters cap: %d\n", cap(waiters))

    var threads int
    for threads = 0; threads < totalThreads; threads++ {
        fmt.Println("start worker")
        go process(queue, waiters) // 启动工作Goroutine
    }
    fmt.Printf("threads started: %d\n", threads)

    // 等待所有工作Goroutine完成
    for ; threads > 0; threads-- {
        fmt.Println("wait for thread")
        <-waiters // 阻塞等待工作Goroutine的完成通知
        fmt.Printf("received thread end\n")
    }
    fmt.Println("All workers finished processing.")
}

func main() {
    myQ := &myQueue{
        pool: []*entry{
            {name: "task1"},
            {name: "task2"},
            {name: "task3"},
        },
        maxConcurrent: 1, // 示例中只启动一个工作Goroutine
    }
    fillQueue(myQ)
}

push entry: task1
push entry: task2
push entry: task3
entry cap: 3
waiters cap: 1
start worker
threads started: 1
wait for thread
worker: processing task1
worker: processing task2
worker: processing task3
fatal error: all goroutines are asleep - deadlock!

package main

import (