我是 Go 的新手，正在尝试实现网络爬虫。它应该异步解析网页并将其内容保存到文件中，每个新页面一个文件。但是在我添加之后它就卡住了

u, _ := url.Parse(uri)
fileName := u.Host + u.RawQuery + ".html"
body, err := ioutil.ReadAll(resp.Body)
writes <- writer{fileName: fileName, body: body}

谁能帮我解决这个问题？基本上我想从响应体中获取数据，将其推送到 channel ，然后从 channel 中获取数据并将其放入文件中。 看起来 writes channel 没有初始化，并且在 nil channel 上发送永远阻塞。

package main

import (
    "crypto/tls"
    "flag"
    "fmt"
    "io/ioutil"
    "net/http"
    "net/url"
    "os"
    "runtime"

    "./linksCollector"
)

type writer struct {
    fileName string
    body     []byte
}

var writes = make(chan writer)

func usage() {
    fmt.Fprintf(os.Stderr, "usage: crawl http://example.com/")
    flag.PrintDefaults()
    os.Exit(2)
}

func check(e error) {
    if e != nil {
        panic(e)
    }
}

func main() {
    runtime.GOMAXPROCS(8)
    flag.Usage = usage
    flag.Parse()

    args := flag.Args()
    fmt.Println(args)
    if len(args) < 1 {
        usage()
        fmt.Println("Please specify start page")
        os.Exit(1)
    }

    queue := make(chan string)
    filteredQueue := make(chan string)

    go func() { queue <- args[0] }()
    go filterQueue(queue, filteredQueue)

    for uri := range filteredQueue {
        go enqueue(uri, queue)
    }

    for {
        select {
        case data := <-writes:
            f, err := os.Create(data.fileName)
            check(err)
            defer f.Close()
            _, err = f.Write(data.body)
            check(err)
        }
    }
}

func filterQueue(in chan string, out chan string) {
    var seen = make(map[string]bool)
    for val := range in {
        if !seen[val] {
            seen[val] = true
            out <- val
        }
    }
}

func enqueue(uri string, queue chan string) {
    fmt.Println("fetching", uri)
    transport := &http.Transport{
        TLSClientConfig: &tls.Config{
            InsecureSkipVerify: true,
        },
    }
    client := http.Client{Transport: transport}
    resp, err := client.Get(uri)
    check(err)

    defer resp.Body.Close()

    u, _ := url.Parse(uri)
    fileName := u.Host + u.RawQuery + ".html"
    body, err := ioutil.ReadAll(resp.Body)
    writes <- writer{fileName: fileName, body: body}

    links := collectlinks.All(resp.Body)

    for _, link := range links {
        absolute := fixURL(link, uri)
        if uri != "" {
            go func() { queue <- absolute }()
        }
    }
}

func fixURL(href, base string) string {
    uri, err := url.Parse(href)
    if err != nil {
        return ""
    }
    baseURL, err := url.Parse(base)
    if err != nil {
        return ""
    }
    uri = baseURL.ResolveReference(uri)
    return uri.String()
}

最佳答案

您的 for 循环最终会在 select 收到导致发送到 的数据之前多次调用 go enqueue >写让程序崩溃，我想，我对Go的并发不是很熟悉。

更新:对于之前的回答，我深表歉意，这是一次缺乏见识的尝试，试图解释我所知有限的事情。在仔细观察之后，我几乎确定了两件事。 1. 您的writes channel 不是nil，您可以依靠make 来初始化您的 channel 。 2. channel 上的range 循环将阻塞，直到该 channel 关闭。所以你的

for uri := range filteredQueue {
    go enqueue(uri, queue)
}

是阻塞的，因此您的程序永远不会到达 select，因此无法从 writes channel 接收。您可以通过在新的 goroutine 中执行 range 循环来避免这种情况。

go func() {
    for uri := range filteredQueue {
        go enqueue(uri, queue)
    }
}()

你的程序，照原样，仍然会因为其他原因而中断，但你应该能够通过使用 sync.WaitGroup 的一点同步来修复它。 这是一个简化的示例:https://play.golang.org/p/o2Oj4g8c2y .

关于Go网络爬虫卡住了，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43091005/