在低配Windows PC上利用Golang并发实现百万次GET请求

你的代码问题在于为每个IP地址创建了独立的HTTP客户端，并且没有控制并发协程数量。当处理5万个IP时，每个IP还会发起最多5次请求（page < 251），这会导致同时打开大量网络连接和文件描述符。

以下是改进方案，使用连接池和协程池来控制并发：

package main

import (
    "bufio"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "net/url"
    "os"
    "regexp"
    "strings"
    "sync"
    "time"
)

const (
    maxConcurrent = 100      // 控制最大并发协程数
    maxFileDescriptors = 100 // 控制最大文件描述符
    timeout = 30 * time.Second // 请求超时时间
)

var (
    wg sync.WaitGroup
    client *http.Client
)

func init() {
    // 创建共享的HTTP客户端，启用连接池
    client = &http.Client{
        Transport: &http.Transport{
            MaxIdleConns:        maxFileDescriptors,
            MaxIdleConnsPerHost: maxFileDescriptors,
            IdleConnTimeout:     90 * time.Second,
        },
        Timeout: timeout,
    }
}

func main() {
    file, err := os.Open("ip.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    
    outfile, err := os.Create("urls.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer outfile.Close()
    
    // 创建带缓冲的通道控制并发
    semaphore := make(chan struct{}, maxConcurrent)
    results := make(chan []string, maxConcurrent)
    
    // 结果写入协程
    go func() {
        for output := range results {
            for _, url := range output {
                fmt.Fprintln(outfile, url)
            }
        }
    }()
    
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        ip := scanner.Text()
        if ip == "" {
            continue
        }
        
        wg.Add(1)
        semaphore <- struct{}{} // 获取信号量
        
        go func(ip string) {
            defer wg.Done()
            defer func() { <-semaphore }() // 释放信号量
            
            Grabber(ip, results)
        }(ip)
    }
    
    wg.Wait()
    close(results)
    
    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }
}

func Grabber(ip string, results chan []string) {
    var output []string
    page := 1
    
    for page < 251 {
        req, err := http.NewRequest(
            http.MethodGet,
            fmt.Sprintf(
                "http://www.bing.com/search?q=ip:%s+&count=50&first=%d",
                url.QueryEscape(ip),
                page,
            ),
            nil,
        )
        if err != nil {
            log.Println("创建请求失败:", err)
            break
        }
        
        req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 6.1; rv:57.0) Gecko/20100101 Firefox/57.0")
        
        res, err := client.Do(req)
        if err != nil {
            log.Println("请求失败:", err)
            break
        }
        
        body, err := ioutil.ReadAll(res.Body)
        res.Body.Close() // 立即关闭响应体
        
        if err != nil {
            log.Println("读取响应失败:", err)
            break
        }
        
        re := regexp.MustCompile(`<h2><a href="(.*?)"`)
        links := re.FindAllString(string(body), -1)
        
        if links != nil {
            for _, link := range links {
                o := strings.Split(link, `"`)
                if len(o) >= 2 {
                    d := strings.Split(o[1], "/")
                    if len(d) >= 3 {
                        s := d[0] + "//" + d[2]
                        if !stringInArray(s, output) {
                            output = append(output, s)
                        }
                    }
                }
            }
        }
        
        page += 50
    }
    
    if len(output) > 0 {
        results <- output
    }
}

func stringInArray(str string, arr []string) bool {
    for _, s := range arr {
        if s == str {
            return true
        }
    }
    return false
}

关键改进：

1. 使用共享HTTP客户端：避免为每个请求创建新客户端，启用连接池复用连接
2. 协程池模式：通过带缓冲的通道控制最大并发协程数
3. 立即关闭响应体：使用res.Body.Close()替代defer，及时释放资源
4. 超时控制：为HTTP客户端设置超时，防止长时间占用连接
5. 连接数限制：通过MaxIdleConns和MaxIdleConnsPerHost限制最大连接数

这个方案将并发协程数限制在100个，同时通过连接池复用TCP连接，显著减少文件描述符的使用。对于5万个IP地址，每个IP最多5次请求，总共25万次请求，但并发连接数被控制在100个以内。