Go语言中缓冲通道的应用场景与优势

package main

import (
    "fmt"
    "time"
)

func longLastingProcess(c chan string, id int) {
    fmt.Printf("Goroutine %d: 开始处理...\n", id)
    time.Sleep(2000 * time.Millisecond) // 模拟耗时操作
    c <- fmt.Sprintf("Goroutine %d: 处理完成", id)
    fmt.Printf("Goroutine %d: 数据已发送\n", id)
}

func main() {
    c := make(chan string) // 创建一个无缓冲通道
    fmt.Println("启动三个并发任务...")

    go longLastingProcess(c, 1)
    go longLastingProcess(c, 2)
    go longLastingProcess(c, 3)

    // 由于是无缓冲通道，每次接收都会阻塞，直到一个goroutine发送数据
    // 且由于fmt.Println(<- c)只会执行一次，因此只能接收到一个值
    fmt.Println("主Goroutine: 接收到:", <-c)
    // 如果需要接收所有发送的值，需要多次接收
    // fmt.Println("主Goroutine: 接收到:", <-c)
    // fmt.Println("主Goroutine: 接收到:", <-c)

    time.Sleep(3 * time.Second) // 等待其他goroutine完成，以便观察输出
    fmt.Println("程序结束。")
}

package main

import (
    "fmt"
    "time"
)

// 任务生产者
func taskScheduler(jobs chan<- string, numJobs int) {
    for i := 1; i <= numJobs; i++ {
        job := fmt.Sprintf("任务-%d", i)
        jobs <- job // 将任务发送到缓冲通道
        fmt.Printf("调度器: 发送 %s\n", job)
        time.Sleep(100 * time.Millisecond) // 模拟调度器快速生成任务
    }
    close(jobs) // 所有任务发送完毕后关闭通道
}

// 任务消费者
func worker(id int, jobs <-chan string, results chan<- string) {
    for job := range jobs {
        fmt.Printf("工作者 %d: 开始处理 %s\n", id, job)
        time.Sleep(500 * time.Millisecond) // 模拟工作者处理任务耗时
        result := fmt.Sprintf("工作者 %d: 完成 %s", id, job)
        results <- result
        fmt.Printf("工作者 %d: 完成 %s\n", id, job)
    }
}

func main() {
    const numJobs = 10
    const bufferSize = 3 // 缓冲通道容量

    jobs := make(chan string, bufferSize)   // 创建一个容量为3的缓冲通道
    results := make(chan string, numJobs) // 用于收集结果的缓冲通道

    // 启动多个工作者goroutine
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 启动任务调度器goroutine
    go taskScheduler(jobs, numJobs)

    // 收集所有任务结果
    for a := 1; a <= numJobs; a++ {
        fmt.Println(<-results)
    }
    fmt.Println("所有任务处理完毕。")
}