Golang互斥锁实现并发爬虫的URL去重方案

以下是针对你代码的专业分析：

主要问题分析

1. 锁传递问题

你的 setVisited 函数接收的是 sync.Mutex 的值拷贝，这会导致每个 goroutine 使用不同的锁实例：

// 错误：传递了锁的值拷贝
func setVisited(url string, visited map[string]bool, lock sync.Mutex) {
    lock.Lock()
    visited[url] = true
    lock.Unlock()
}

// 正确：应该传递锁的指针
func setVisited(url string, visited map[string]bool, lock *sync.Mutex) {
    lock.Lock()
    visited[url] = true
    lock.Unlock()
}

2. 并发安全实现方案

这里提供一个改进的实现方案：

package main

import (
    "fmt"
    "sync"
)

type SafeVisited struct {
    mu      sync.Mutex
    visited map[string]bool
}

func (sv *SafeVisited) Set(url string) bool {
    sv.mu.Lock()
    defer sv.mu.Unlock()
    
    if sv.visited[url] {
        return false
    }
    sv.visited[url] = true
    return true
}

func (sv *SafeVisited) Get(url string) bool {
    sv.mu.Lock()
    defer sv.mu.Unlock()
    return sv.visited[url]
}

func Crawl(url string, depth int, fetcher Fetcher, sv *SafeVisited, wg *sync.WaitGroup) {
    defer wg.Done()
    
    if depth <= 0 {
        return
    }
    
    // 原子性检查并设置已访问
    if !sv.Set(url) {
        return
    }
    
    body, urls, err := fetcher.Fetch(url)
    if err != nil {
        fmt.Println(err)
        return
    }
    
    fmt.Printf("found: %s %q\n", url, body)
    
    // 并发抓取子链接
    for _, u := range urls {
        wg.Add(1)
        go Crawl(u, depth-1, fetcher, sv, wg)
    }
}

func main() {
    sv := &SafeVisited{
        visited: make(map[string]bool),
    }
    
    var wg sync.WaitGroup
    wg.Add(1)
    go Crawl("https://golang.org/", 4, fetcher, sv, &wg)
    wg.Wait()
    
    fmt.Println("Visited URLs:", sv.visited)
}

3. 关于 time.Sleep 的问题

time.Sleep(time.Second) 在原始代码中是必需的，因为：

• 主 goroutine 在启动所有子 goroutine 后立即退出
• 子 goroutine 没有足够时间执行
• 使用 sync.WaitGroup 可以正确同步 goroutine 的执行

4. 通道方案示例

如果需要使用通道进行协调：

func CrawlWithChannel(url string, depth int, fetcher Fetcher, sv *SafeVisited) {
    type crawlTask struct {
        url   string
        depth int
    }
    
    tasks := make(chan crawlTask, 100)
    var wg sync.WaitGroup
    
    // 启动固定数量的 worker
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for task := range tasks {
                if task.depth <= 0 {
                    continue
                }
                
                if !sv.Set(task.url) {
                    continue
                }
                
                body, urls, err := fetcher.Fetch(task.url)
                if err != nil {
                    fmt.Println(err)
                    continue
                }
                
                fmt.Printf("found: %s %q\n", task.url, body)
                
                // 将子链接加入任务队列
                for _, u := range urls {
                    tasks <- crawlTask{url: u, depth: task.depth - 1}
                }
            }
        }()
    }
    
    // 提交初始任务
    tasks <- crawlTask{url: url, depth: depth}
    close(tasks)
    wg.Wait()
}

关键改进点

1. 使用结构体封装：将互斥锁和映射封装在一起，确保数据一致性
2. 使用指针传递锁：避免锁的值拷贝问题
3. 添加 WaitGroup：正确等待所有 goroutine 完成
4. 原子性操作：在锁的保护下同时完成检查和设置操作

这个实现确保了并发安全，避免了数据竞争，并且不需要使用 time.Sleep 来等待 goroutine 完成。