深入理解Go并发：优化网络I/O与分块下载实践

func download(uri string, chunks chan int, offset int, file *os.File) {
    for current := range chunks {
        fmt.Println("downloading range: ", current, "-", current+offset)
        client := &http.Client{}
        req, _ := http.NewRequest("GET", uri, nil)
        req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", current, current+offset))
        resp, err := client.Do(req)
        if err != nil {
            panic(err)
        }
        defer resp.Body.Close()
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            panic(err)
        }
        file.Write(body) // 写入文件
    }
}

// 主函数中可能的调用
// go download(*download_url, chunks, offset, file) // 仅启动了一个goroutine

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
    "sync" // 用于等待所有goroutine完成
)

// download 函数保持不变，或者稍作修改以适应实际需求
func download(uri string, chunks <-chan int, offset int, file *os.File, wg *sync.WaitGroup) {
    defer wg.Done() // 确保goroutine完成时通知WaitGroup

    for current := range chunks {
        fmt.Printf("Downloading range: %d-%d\n", current, current+offset-1) // 修正Range头，见下文
        client := &http.Client{}
        req, err := http.NewRequest("GET", uri, nil)
        if err != nil {
            fmt.Printf("Error creating request: %v\n", err)
            continue
        }
        // 修正Range头，避免重复下载字节
        req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", current, current+offset-1))

        resp, err := client.Do(req)
        if err != nil {
            fmt.Printf("Error during HTTP request for range %d-%d: %v\n", current, current+offset-1, err)
            continue
        }
        defer resp.Body.Close()

        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            fmt.Printf("Error reading response body for range %d-%d: %v\n", current, current+offset-1, err)
            continue
        }

        // 使用WriteAt确保数据写入正确位置
        _, err = file.WriteAt(body, int64(current))
        if err != nil {
            fmt.Printf("Error writing to file at offset %d: %v\n", current, err)
            continue
        }
    }
}

func main() {
    downloadURL := "http://example.com/largefile.zip" // 替换为实际下载地址
    numThreads := 4                                  // 设置并发下载的goroutine数量
    chunkSize := 1024 * 1024                         // 每个分块1MB

    // 假设文件总大小已知，这里为了示例简单，假设一个固定值
    // 实际应用中，需要先发送HEAD请求获取文件大小
    fileSize := 10 * 1024 * 1024 // 10MB

    file, err := os.Create("downloaded_file.zip")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    chunks := make(chan int, numThreads) // 缓冲通道，防止发送端阻塞
    var wg sync.WaitGroup

    // 启动指定数量的goroutine
    for i := 0; i < numThreads; i++ {
        wg.Add(1)
        go download(downloadURL, chunks, chunkSize, file, &wg)
    }

    // 分发下载任务
    for i := 0; i < int(fileSize); i += chunkSize {
        chunks <- i
    }
    close(chunks) // 关闭通道，通知goroutine没有更多任务

    wg.Wait() // 等待所有goroutine完成
    fmt.Println("Download complete!")
}

// 在 download 函数中
// ...
// body, err := ioutil.ReadAll(resp.Body)
// ...
_, err = file.WriteAt(body, int64(current)) // current 是该分块的起始偏移量
if err != nil {
    fmt.Printf("Error writing to file at offset %d: %v\n", current, err)
    // 适当的错误处理
}

// 在 download 函数中
// ...
// 修正Range头，避免重复下载字节
req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", current, current+offset-1))
// ...

// 在 main 函数中分发任务时，需要考虑最后一个分块
// 假设 fileSize 是文件的总字节数
for i := 0; i < int(fileSize); i += chunkSize {
    endByte := i + chunkSize - 1
    if endByte >= int(fileSize) {
        endByte = int(fileSize) - 1 // 确保不超过文件实际大小
    }
    // 实际发送给goroutine的可能是一个结构体，包含起始和结束偏移量
    // 或者像当前示例，goroutine内部根据current和chunkSize计算
    chunks <- i // current 代表起始偏移量
}