答案：Go语言通过goroutine和channel可实现轻量级线程池，控制并发数量以避免资源耗尽。核心组件包括任务函数、任务通道、worker数量和WaitGroup。使用固定数量的worker从带缓冲通道中取任务执行，通过Submit提交任务，Shutdown关闭通道并等待完成。示例中创建3个worker、队列大小为10的线程池，用于批量处理任务。该模式适用于文件处理、网络请求控制和定时任务等场景，具有调度开销小、高效利用多核的优势。需注意合理设置worker数、避免Submit阻塞及长时间任务影响复用。

在 Linux 系统开发中，Go 语言的协程（goroutine）配合通道（channel）可以非常方便地实现轻量级线程池，有效控制并发数量，避免资源耗尽。虽然 Go 自身调度器已经高度优化，但在处理大量任务时，限制并发 goroutine 数量依然很有必要。下面介绍如何用 Go 协程构建一个简单高效的线程池。

基本思路：使用 worker + 任务队列

线程池的核心是固定数量的工作协程（worker），它们从一个共享的任务通道中获取任务并执行。主程序通过向通道发送任务来调度执行，从而实现并发控制。

关键组件：

• 任务函数：需要执行的具体逻辑，通常封装为函数类型
• 任务通道：用于传递任务，类型为 chan func()
• Worker 数量：控制并发的 goroutine 数量
• WaitGroup：等待所有任务完成

实现一个简单的线程池

以下是一个可复用的轻量线程池示例：

package main

import (
    "fmt"
    "sync"
)

type Task func()

type Pool struct {
    workers int
    tasks   chan Task
    wg      sync.WaitGroup
}

func NewPool(workers, queueSize int) *Pool {
    return &Pool{
        workers: workers,
        tasks:   make(chan Task, queueSize),
    }
}

func (p *Pool) Start() {
    for i := 0; i < p.workers; i++ {
        p.wg.Add(1)
        go func() {
            defer p.wg.Done()
            for task := range p.tasks {
                task()
            }
        }()
    }
}

func (p *Pool) Submit(task Task) {
    p.tasks <- task
}

func (p *Pool) Shutdown() {
    close(p.tasks)
    p.wg.Wait()
}

// 使用示例
func main() {
    pool := NewPool(3, 10) // 3 个 worker，队列最多 10 个任务
    pool.Start()

    for i := 0; i < 5; i++ {
        i := i
        pool.Submit(func() {
            fmt.Printf("执行任务 %d\n", i)
        })
    }

    pool.Shutdown()
    fmt.Println("所有任务完成")
}

优势与适用场景

这种模式在 Linux 开发中特别实用，比如：

• 批量处理文件或日志：限制同时打开的文件描述符数量
• 网络请求并发控制：避免对远程服务造成过大压力
• 定时任务调度：后台异步执行而不阻塞主线程

由于每个 worker 是一个轻量 goroutine，系统调度开销极小，加上 Go runtime 的多路复用机制，能高效利用多核 CPU。

注意事项

使用时注意以下几点：

• 任务通道建议设为带缓冲的，避免 Submit 阻塞
• Submit 不应发生在 Shutdown 之后，否则会 panic
• 长时间阻塞任务会影响 worker 复用，需合理拆分
• 可根据需要扩展支持任务返回值或错误处理

基本上就这些。Go 的并发模型让线程池实现变得异常简洁，不需要复杂的锁或条件变量，靠 channel 和 goroutine 就能构建出稳定高效的并发控制结构。不复杂但容易忽略的是合理设置 worker 数量，一般建议根据实际负载和系统资源调整。