Go的工作池（worker-pools）

工作池是一种常用的并发设计模式，它利用一组固定数量的 goroutine 来处理一组任务。任务可以被异步地添加到工作池中，等待可用的 worker goroutine 来处理。当没有更多的任务需要处理时，worker goroutine 将会保持空闲状态，等待新的任务到来。 在 Go 中，我们可以使用通道和 Goroutine 来实现这种模式。下面是一个基本的工作池示例：

package main

import (
    "fmt"
    "sync"
)

type Job struct {
    id int
}

type Result struct {
    job  Job
    done bool
}

func worker(id int, jobs <-chan Job, results chan<- Result) {
    for job := range jobs {
        fmt.Printf("worker %d started job %d\n", id, job.id)
        // 处理任务
        fmt.Printf("worker %d finished job %d\n", id, job.id)
        results <- Result{job, true}
    }
}

func main() {
    const numJobs = 5
    jobs := make(chan Job, numJobs)
    results := make(chan Result, numJobs)

    var wg sync.WaitGroup

    // 创建多个 worker
    numWorkers := 3
    for w := 1; w <= numWorkers; w++ {
        go worker(w, jobs, results)
    }

    // 添加任务
    for j := 1; j <= numJobs; j++ {
        jobs <- Job{j}
    }
    close(jobs)

    // 等待所有任务执行完成
    for a := 1; a <= numJobs; a++ {
        result := <-results
        fmt.Printf("job %d done\n", result.job.id)
    }
}

在这个例子中，我们定义了一个 `Job` 结构体，它包含一个简单的 ID，我们还定义了一个 `Result` 结构体，它包含一个 `Job` 和一个 `done` 布尔值，表示任务是否已完成。

然后我们定义了一个 `worker` 函数，它接受一个 worker 的 `id`、一个 `jobs` channel、一个 `results` channel。

worker 不断从 `jobs` channel 中读取任务，完成任务后将任务的 `id` 以及一个 `done` 标志写入 `results` channel 中。在这个例子中，我们只是简单地输出任务的信息，当然，实际应用场景中任务可千不止这些简单了。

在主函数中，我们首先创建了一个缓冲 channel `jobs`，用于存储任务，并向其中添加了 5 个任务。然后，我们创建了一个缓冲 channel `results`，用于存储 worker 的返回结果。接下来，我们启动了 3 个 worker goroutine，分别处理 `jobs` channel 中的任务。 等所有任务都执行完成后，我们使用一个简单的 for 循环来读取 `results` channel 中的结果并输出。这里需要注意的是，如果 channel 没有被关闭，那么 range 语句就会一直阻塞在那里，直到 channel 被关闭。 通过使用面向通道的并发编程，我们可以很容易地实现一个简单的工作池，以便更有效地利用计算机的多个处理器核心，并在多个协程之间共享和管理任务。