Go语言实现并发网络爬虫：串行、互斥锁与通道三种模式对比

周叙

发布时间：2026-10-15 | 5人浏览过

原创

在Go语言开发中，利用其原生并发特性优化网络爬虫是常见需求。本文通过串行执行、互斥锁保护共享状态和使用通道通信三种递进方案，演示如何实现高效的并发URL爬取，重点解析竞态条件的处理与Goroutine管理。

核心目标与准备工作

本示例旨在从起始页面提取所有URL，并将这些URL加入待抓取的列表中进行处理。由于网页链接存在循环引用的可能，必须维护一个已访问集合以防止重复抓取。我们将忽略具体的页面解析逻辑（实际项目中建议使用 colly 等成熟框架），仅聚焦于Go的并发控制机制。

第一步：串行爬取（基准实现）

最简单的实现方式是顺序执行。主函数调用递归函数，依次处理每个URL。由于Go中的map是引用类型，每次递归都能访问到相同的已获取记录。

func Serial(url string, fetcher Fetcher, fetched map[string]bool) {
    if fetched[url] {
        return
    }
    fetched[url] = true
    urls, err := fetcher.Fetch(url)
    if err != nil {
        return
    }
    for _, u := range urls {
        Serial(u, fetcher, fetched)
    }
    return
}

func main() {
    Serial("<page>", fetcher, make(map[string]bool))
}

此方法虽然简单，但完全串行执行，受限于网络I/O延迟，无法发挥多核优势。

第二步：使用互斥锁并发（sync.Mutex）

为了提高速度，我们引入Goroutine并行处理。此时需要解决共享资源 fetched map 的读写竞争问题。我们通过 sync.Mutex 来锁定Map，确保同一时间只有一个Goroutine能修改或检查该状态。

type fetchState struct {
    mu      sync.Mutex
    fetched map[string]bool
}

func makeState() *fetchState {
    f := &fetchState{}
    f.fetched = make(map[string]bool)
    return f
}

func ConcurrentMutex(url string, fetcher Fetcher, f *fetchState) {
    // 1. 加锁检查并标记为已获取
    f.mu.Lock()
    already := f.fetched[url]
    f.fetched[url] = true
    f.mu.Unlock()

    // 如果已被其他协程处理，直接返回
    if already {
        return
    }

    // 2. 发起请求
    urls, err := fetcher.Fetch(url)
    if err != nil {
        return
    }

    // 3. 为每个新URL启动新的Goroutine
    var done sync.WaitGroup
    for _, u := range urls {
        done.Add(1)
        go func(u string) {
            defer done.Done()
            ConcurrentMutex(u, fetcher, f)
        }(u)
    }
    // 4. 等待所有子协程完成
    done.Wait()
    return
}

func main() {
    ConcurrentMutex("<page>", fetcher, makeState())
}

关键细节说明

锁的作用范围：必须在检查 fetched[url] 并设置 true 的过程中保持加锁，防止两个线程同时读取到 false 然后都去发起请求。
闭包变量捕获：在 go func(u string) 中将 u 作为参数传入至关重要。如果不传参直接使用外层循环变量 u，当循环快速迭代时，Goroutine启动后引用的可能是已经被修改的 u 值。
WaitGroup的使用： defer done.Done() 确保即使在 Fetch 出错时也能正确递减计数器，避免死锁。
数据竞争检测：可通过 go run -race . 命令运行程序，Go运行时将自动检测潜在的竞态条件。

注意：此版本未限制并发数量，可能会创建大量Goroutine。虽然Go调度器能高效管理轻量级线程，但在极端情况下仍建议配合Worker Pool模式限制并发度。

第三步：使用通道通信（Concurrent Channel）

另一种经典的并发范式是“不要通过共享内存来通信，而要通过通信来共享内存”。在此模式中，只有一个主控Goroutine负责跟踪已访问的URL和协调工作流，其他工作协程仅通过通道发送结果，无需显式加锁。

func ConcurrentChannel(url string, fetcher Fetcher) {
    ch := make(chan []string)
    // 向通道发送初始URL
    go func() {
        ch <- []string{url}
    }()
    master(ch, fetcher)
}

func master(ch chan []string, fetcher Fetcher) {
    n := 1 // 用于统计当前活跃或待处理的请求数
    fetched := make(map[string]bool)

    for urls := range ch {
        for _, u := range urls {
            if !fetched[u] {
                fetched[u] = true
                n += 1
                go worker(u, ch, fetcher)
            }
        }
        n -= 1
        if n == 0 {
            break
        }
    }
}

func worker(url string, ch chan []string, fetcher Fetcher) {
    urls, err := fetcher.Fetch(url)
    if err != nil {
        ch <- []string{}
    } else {
        ch <- urls
    }
}