Go语言HTTP服务中文件读取与ResponseWriter的并发处理

func writeContent(w http.ResponseWriter, channel chan []byte) {
    fmt.Printf("ATTEMPTING TO WRITE CONTENT\n")
    go func() { // 问题根源：这里启动了一个新的Goroutine
        for bytes := range channel {
            w.Write(bytes)
            fmt.Printf("BYTES RECEIVED\n")
        }
    }()
    fmt.Printf("FINISHED WRITING\n") // 此行可能在w.Write完成前执行
}

package defp

import (
    "fmt"
    "net/http" // 使用 net/http 代替 http
    "os"
    "io" // 引入 io 包，方便后续提及 io.Copy
)

// getContent 函数：负责读取文件内容并发送到通道
func getContent(filename string, channel chan []byte) {
    file, err := os.OpenFile(filename, os.O_RDONLY, 0666)
    defer func() {
        if file != nil {
            file.Close() // 确保文件句柄关闭
        }
    }()

    if err == nil {
        fmt.Printf("FILE FOUND : " + filename + " \n")
        buffer := make([]byte, 16)
        dat, err := file.Read(buffer)
        for err == nil {
            fmt.Printf("herp")
            channel <- buffer[0:dat]
            buffer = make([]byte, 16) // 每次循环重新分配缓冲区以避免数据覆盖问题
            dat, err = file.Read(buffer)
        }
        close(channel) // 读取完毕后关闭通道
        fmt.Printf("DONE READING\n")
    } else {
        fmt.Printf("FILE NOT FOUND : " + filename + " \n")
        close(channel) // 文件未找到也应关闭通道，防止接收端阻塞
    }
}

// writeContent 函数：负责从通道接收内容并写入 http.ResponseWriter
// 注意：此函数不再启动新的Goroutine，而是在当前Goroutine中阻塞执行
func writeContent(w http.ResponseWriter, channel chan []byte) {
    fmt.Printf("ATTEMPTING TO WRITE CONTENT\n")
    for bytes := range channel {
        _, err := w.Write(bytes) // 写入并检查错误
        if err != nil {
            fmt.Printf("Error writing bytes: %v\n", err)
            // 生产环境中应有更完善的错误处理，例如返回HTTP错误
            return
        }
        fmt.Printf("BYTES RECEIVED\n")
    }
    fmt.Printf("FINISHED WRITING\n")
}

// load 函数：协调文件读取和写入
func load(w http.ResponseWriter, path string) {
    fmt.Printf("ATTEMPTING LOAD " + path + "\n")
    // 创建一个无缓冲通道，确保发送和接收同步
    channel := make(chan []byte)
    // 创建一个用于同步Goroutine完成的通道
    workDone := make(chan byte, 2) // 缓冲大小为2，因为有两个Goroutine会发送信号

    // 启动一个Goroutine来执行写入操作
    go func() {
        writeContent(w, channel)
        workDone <- 1 // 写入操作完成后发送信号
    }()

    // 启动一个Goroutine来执行文件读取操作
    go func() {
        getContent(path, channel)
        workDone <- 2 // 读取操作完成后发送信号
    }()

    // 阻塞等待两个Goroutine都完成其工作
    <-workDone
    <-workDone
    fmt.Printf("ALL WORK DONE IN LOAD\n")
}

// handle 函数：HTTP请求处理入口
func handle(w http.ResponseWriter, r *http.Request) {
    fmt.Printf("HANDLING REQUEST FOR " + r.URL.Path[1:] + "\n")
    load(w, r.URL.Path[1:])
    fmt.Printf("HANDLER FINISHED\n")
}

func init() {
    http.HandleFunc("/", handle)
}

import (
    "net/http"
    "os"
    "io" // 确保导入 io 包
)

// loadWithIOCopy 函数：使用 io.Copy 直接将文件内容写入 ResponseWriter
func loadWithIOCopy(w http.ResponseWriter, path string) {
    fmt.Printf("ATTEMPTING LOAD " + path + " with io.Copy\n")
    file, err := os.Open(path) // 打开文件
    if err != nil {
        // 文件未找到或打开失败，返回404或500错误
        http.Error(w, "File not found or cannot open: "+err.Error(), http.StatusNotFound)
        return
    }
    defer file.Close() // 确保文件句柄关闭

    // 使用 io.Copy 将文件内容直接复制到 ResponseWriter
    // io.Copy 会阻塞直到所有数据复制完成或发生错误
    _, err = io.Copy(w, file)
    if err != nil {
        // 写入过程中发生错误
        fmt.Printf("Error copying file content to response: %v\n", err)
        // 生产环境中应有更完善的错误处理
        return
    }
    fmt.Printf("File content successfully served with io.Copy\n")
}

// handle 函数中调用 loadWithIOCopy
func handleIOCopy(w http.ResponseWriter, r *http.Request) {
    fmt.Printf("HANDLING REQUEST FOR " + r.URL.Path[1:] + " with io.Copy\n")
    loadWithIOCopy(w, r.URL.Path[1:])
    fmt.Printf("HANDLER FINISHED\n")
}

// init 函数中注册 handleIOCopy
// func init() {
//     http.HandleFunc("/", handleIOCopy)
// }