Go REST API中的Goroutine：何时需要以及如何有效利用

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

// simulateLongRunningTask 模拟一个耗时操作
func simulateLongRunningTask(taskID string) {
    log.Printf("开始执行耗时任务：%s...", taskID)
    time.Sleep(5 * time.Second) // 模拟5秒钟的工作
    log.Printf("耗时任务 %s 完成。", taskID)
}

// simpleHandler 处理简单请求，无需显式Goroutine
func simpleHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "这是一个简单的响应，由标准库的Goroutine处理。")
}

// asyncTaskHandler 处理需要异步执行任务的请求
func asyncTaskHandler(w http.ResponseWriter, r *http.Request) {
    taskID := fmt.Sprintf("task-%d", time.Now().UnixNano())
    // 启动一个新的Goroutine来执行耗时任务
    go simulateLongRunningTask(taskID) 

    // 立即向客户端发送响应
    fmt.Fprintf(w, "任务 %s 已在后台启动，请稍后查看结果。", taskID)
}

func main() {
    http.HandleFunc("/simple", simpleHandler)
    http.HandleFunc("/async", asyncTaskHandler)

    log.Println("服务器正在监听 :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// 假设需要从后台任务获取结果
func backgroundWorker(input string, resultChan chan string, errChan chan error) {
    defer close(resultChan) // 确保通道在任务结束时关闭
    defer close(errChan)

    time.Sleep(2 * time.Second) // 模拟工作
    if input == "error" {
        errChan <- fmt.Errorf("处理 %s 时发生错误", input)
        return
    }
    resultChan <- fmt.Sprintf("处理 %s 成功", input)
}

func handlerWithResult(w http.ResponseWriter, r *http.Request) {
    resultChan := make(chan string)
    errChan := make(chan error)

    go backgroundWorker("some_data", resultChan, errChan)

    select {
    case result := <-resultChan:
        fmt.Fprintf(w, "后台任务结果: %s", result)
    case err := <-errChan:
        http.Error(w, fmt.Sprintf("后台任务错误: %v", err), http.StatusInternalServerError)
    case <-time.After(3 * time.Second): // 设置超时
        http.Error(w, "后台任务超时", http.StatusRequestTimeout)
    }
}

import (
    "context"
    "time"
)

func cancellableTask(ctx context.Context, taskID string) {
    log.Printf("可取消任务 %s 启动...", taskID)
    select {
    case <-time.After(10 * time.Second): // 模拟长时间工作
        log.Printf("可取消任务 %s 完成。", taskID)
    case <-ctx.Done(): // 接收到取消信号
        log.Printf("可取消任务 %s 被取消: %v", taskID, ctx.Err())
    }
}

func handlerWithCancellation(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second) // 5秒后自动取消
    defer cancel() // 确保在函数退出时调用cancel

    taskID := fmt.Sprintf("cancel-task-%d", time.Now().UnixNano())
    go cancellableTask(ctx, taskID)

    fmt.Fprintf(w, "可取消任务 %s 已启动，将在5秒内自动取消或完成。", taskID)
}