Go语言中Goroutine与标准库及第三方包的并发使用指南

package main

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

// fetchDataSync 模拟一个同步的HTTP GET请求
func fetchDataSync(url string, wg *sync.WaitGroup, results chan<- string) {
    defer wg.Done() // 确保Goroutine完成时通知WaitGroup
    fmt.Printf("Fetching data from: %s\n", url)
    resp, err := http.Get(url)
    if err != nil {
        results <- fmt.Sprintf("Error fetching %s: %v", url, err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        results <- fmt.Sprintf("Error reading body from %s: %v", url, err)
        return
    }
    results <- fmt.Sprintf("Successfully fetched %s, size: %d bytes", url, len(body))
}

func main() {
    urls := []string{
        "https://www.google.com",
        "https://www.bing.com",
        "https://www.yahoo.com",
    }

    var wg sync.WaitGroup
    results := make(chan string, len(urls)) // 使用带缓冲的channel收集结果

    for _, url := range urls {
        wg.Add(1)
        go fetchDataSync(url, &wg, results) // 为每个请求启动一个Goroutine
    }

    wg.Wait() // 等待所有Goroutine完成
    close(results) // 关闭channel，表示所有结果已发送

    // 收集并打印所有结果
    for res := range results {
        fmt.Println(res)
    }

    fmt.Println("All fetches completed.")
}

package main

import (
    "fmt"
    "time"
)

// AsyncProcessor 模拟一个异步处理任务的包
type AsyncProcessor struct{}

// ProcessTaskAsync 模拟一个异步函数，它在内部启动Goroutine并返回一个结果Channel
func (ap *AsyncProcessor) ProcessTaskAsync(taskID int, duration time.Duration) <-chan string {
    resultChan := make(chan string) // 创建一个非缓冲Channel用于发送结果

    go func() {
        defer close(resultChan) // 任务完成后关闭Channel
        fmt.Printf("Processor: Task %d started processing for %v...\n", taskID, duration)
        time.Sleep(duration) // 模拟耗时操作
        resultChan <- fmt.Sprintf("Processor: Task %d completed after %v.", taskID, duration)
    }()

    return resultChan // 立即返回Channel，不阻塞调用者
}

func main() {
    processor := &AsyncProcessor{}

    // 调用异步函数，不需要额外的'go'关键字
    results1 := processor.ProcessTaskAsync(1, 2*time.Second)
    results2 := processor.ProcessTaskAsync(2, 1*time.Second)

    fmt.Println("Main: Tasks initiated, waiting for results...")

    // 使用select语句同时等待多个异步结果
    for i := 0; i < 2; i++ {
        select {
        case res := <-results1:
            fmt.Println("Main:", res)
        case res := <-results2:
            fmt.Println("Main:", res)
        }
    }

    fmt.Println("Main: All async results received.")
}