Go语言实现高效多线程文件下载器：基于HTTP Range与并发控制

package main

import (
    "errors"
    "flag"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "strconv"
    "sync"
    "time"
)

var fileURL string
var workers int
var filename string

func init() {
    flag.StringVar(&fileURL, "url", "", "URL of the file to download")
    flag.StringVar(&filename, "filename", "", "Name of downloaded file")
    flag.IntVar(&workers, "workers", 4, "Number of download workers (default: 4)")
}

// getHeaders fetches file headers to get Content-Length and check server support for Range requests.
func getHeaders(url string) (map[string]string, error) {
    headers := make(map[string]string)
    resp, err := http.Head(url)
    if err != nil {
        return headers, fmt.Errorf("failed to send HEAD request: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return headers, fmt.Errorf("HEAD request returned non-200 status: %s", resp.Status)
    }

    for key, val := range resp.Header {
        headers[key] = val[0] // Take the first value for simplicity
    }

    // Check if server supports Range requests
    if _, ok := headers["Accept-Ranges"]; !ok {
        log.Printf("Warning: Server does not explicitly advertise 'Accept-Ranges' header. Multi-part download might not be fully supported.")
    }
    return headers, nil
}

// OffsetWriter is a custom io.Writer that writes to an io.WriterAt at a specific offset.
type OffsetWriter struct {
    w      io.WriterAt
    offset int64
}

// Write implements the io.Writer interface.
func (ow *OffsetWriter) Write(p []byte) (n int, err error) {
    n, err = ow.w.WriteAt(p, ow.offset)
    ow.offset += int64(n) // Update offset for subsequent writes if any
    return
}

// NewOffsetWriter creates a new OffsetWriter.
func NewOffsetWriter(w io.WriterAt, offset int64) io.Writer {
    return &OffsetWriter{w: w, offset: offset}
}

// downloadChunk downloads a specific byte range of the file.
func downloadChunk(url string, outFile *os.File, start int64, stop int64, wg *sync.WaitGroup, chunkID int) {
    defer wg.Done()

    client := &http.Client{Timeout: 30 * time.Second} // Add a timeout for robustness
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        log.Printf("Worker %d: Failed to create request for range %d-%d: %v", chunkID, start, stop, err)
        return
    }

    // Set the Range header for partial content
    req.Header.Add("Range", fmt.Sprintf("bytes=%d-%d", start, stop))

    resp, err := client.Do(req)
    if err != nil {
        log.Printf("Worker %d: Failed to perform GET request for range %d-%d: %v", chunkID, start, stop, err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusPartialContent && resp.StatusCode != http.StatusOK {
        log.Printf("Worker %d: Server returned unexpected status %s for range %d-%d. Expected 206 or 200.", chunkID, resp.Status, start, stop)
        return
    }

    // Use io.Copy with a custom OffsetWriter to efficiently write at the specified offset
    bytesWritten, err := io.Copy(NewOffsetWriter(outFile, start), resp.Body)
    if err != nil {
        log.Printf("Worker %