Golang在Web应用中的并发与通道实践

在Go语言中，利用并发和通道构建Web应用是一个高效且实用的学习方式。以下是一些具体功能示例，帮助你深入理解goroutine和通道的实际应用，避免重复聊天功能。

1. 实时数据聚合与处理

在Web应用中，可以设计一个功能来并发获取多个外部API数据（如天气、新闻或股票信息），并使用通道协调结果。这能练习goroutine的启动、通道的同步和数据聚合。

示例代码：

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "sync"
)

// 模拟外部API响应结构
type APIResponse struct {
    Source string
    Data   string
}

func fetchAPI(url string, ch chan<- APIResponse, wg *sync.WaitGroup) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        ch <- APIResponse{Source: url, Data: "Error"}
        return
    }
    defer resp.Body.Close()
    // 简化处理：假设返回文本数据
    ch <- APIResponse{Source: url, Data: "Fetched data from " + url}
}

func main() {
    urls := []string{
        "https://api.example.com/weather",
        "https://api.example.com/news",
        "https://api.example.com/stocks",
    }
    ch := make(chan APIResponse, len(urls))
    var wg sync.WaitGroup

    for _, url := range urls {
        wg.Add(1)
        go fetchAPI(url, ch, &wg)
    }

    wg.Wait()
    close(ch)

    // 从通道收集结果
    var results []APIResponse
    for resp := range ch {
        results = append(results, resp)
    }

    // 输出聚合数据（在实际Web应用中，可返回JSON响应）
    jsonData, _ := json.Marshal(results)
    fmt.Println(string(jsonData))
}

2. 后台任务处理与通知

实现一个用户注册功能，当用户注册时，使用goroutine异步发送欢迎邮件，并通过通道传递任务状态。这能学习如何用通道管理后台任务，避免阻塞主请求。

示例代码：

package main

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

// 模拟发送邮件函数
func sendEmail(email string, ch chan<- string) {
    time.Sleep(2 * time.Second) // 模拟邮件发送延迟
    ch <- "Email sent to " + email
}

func registerHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != "POST" {
        http.Error(w, "Invalid method", http.StatusMethodNotAllowed)
        return
    }
    email := r.FormValue("email")
    if email == "" {
        http.Error(w, "Email is required", http.StatusBadRequest)
        return
    }

    // 使用缓冲通道处理邮件发送任务
    ch := make(chan string, 1)
    go sendEmail(email, ch)

    // 立即响应用户，不等待邮件发送
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("Registration successful!"))

    // 可选：记录邮件发送状态（在实际应用中，可写入日志或数据库）
    go func() {
        status := <-ch
        fmt.Println("Background task:", status)
    }()
}

func main() {
    http.HandleFunc("/register", registerHandler)
    http.ListenAndServe(":8080", nil)
}

3. 并发文件上传处理

构建一个文件上传接口，支持多文件并发上传，并使用通道限制并发数以防止资源耗尽。这能练习goroutine池和带缓冲通道的使用。

示例代码：

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
    "path/filepath"
    "sync"
)

// 处理单个文件上传的goroutine
func uploadFile(fileHeader *http.FileHeader, sem chan struct{}, wg *sync.WaitGroup) {
    defer wg.Done()
    defer func() { <-sem }() // 释放信号量槽位

    file, err := fileHeader.Open()
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    // 创建目标文件
    dstPath := filepath.Join("uploads", fileHeader.Filename)
    dst, err := os.Create(dstPath)
    if err != nil {
        fmt.Println("Error creating file:", err)
        return
    }
    defer dst.Close()

    // 复制文件内容
    if _, err := io.Copy(dst, file); err != nil {
        fmt.Println("Error copying file:", err)
        return
    }
    fmt.Println("Uploaded:", fileHeader.Filename)
}

func uploadHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != "POST" {
        http.Error(w, "Invalid method", http.StatusMethodNotAllowed)
        return
    }

    // 解析多部分表单
    if err := r.ParseMultipartForm(32 << 20); err != nil { // 32MB max memory
        http.Error(w, "Error parsing form", http.StatusBadRequest)
        return
    }

    files := r.MultipartForm.File["files"]
    if len(files) == 0 {
        http.Error(w, "No files uploaded", http.StatusBadRequest)
        return
    }

    // 使用带缓冲通道作为信号量，限制并发数为3
    sem := make(chan struct{}, 3)
    var wg sync.WaitGroup

    for _, fileHeader := range files {
        sem <- struct{}{} // 获取信号量槽位
        wg.Add(1)
        go uploadFile(fileHeader, sem, &wg)
    }

    wg.Wait()
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("All files uploaded successfully"))
}

func main() {
    http.HandleFunc("/upload", uploadHandler)
    http.ListenAndServe(":8080", nil)
}

这些示例覆盖了并发数据获取、后台任务和资源管理场景，通过goroutine和通道实现高效处理。在实际部署时，注意错误处理和资源清理。