Go语言并发编程：理解库函数行为与Goroutine的正确使用姿势

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func fetchURL(url string) (string, error) {
    resp, err := http.Get(url) // 这是一个同步调用
    if err != nil {
        return "", fmt.Errorf("failed to fetch URL %s: %w", url, err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return "", fmt.Errorf("failed to read response body: %w", err)
    }
    return string(body), nil
}

func main() {
    // ... 在这里调用 fetchURL 是同步的
}

package main

import (
    "fmt"
    "time"
)

// simulateAsyncOperation 模拟一个异步操作，通过回调函数返回结果
func simulateAsyncOperation(data string, callback func(result string, err error)) {
    go func() {
        time.Sleep(2 * time.Second) // 模拟耗时操作
        if data == "error" {
            callback("", fmt.Errorf("simulated error for data: %s", data))
            return
        }
        callback(fmt.Sprintf("Processed: %s", data), nil)
    }()
}

// simulateAsyncWithChannel 模拟一个异步操作，通过通道返回结果
func simulateAsyncWithChannel(data string) <-chan string {
    resultChan := make(chan string)
    go func() {
        defer close(resultChan)
        time.Sleep(1 * time.Second) // 模拟耗时操作
        resultChan <- fmt.Sprintf("Channel Processed: %s", data)
    }()
    return resultChan
}

func main() {
    fmt.Println("开始异步操作...")

    // 使用回调函数
    simulateAsyncOperation("input_data_1", func(result string, err error) {
        if err != nil {
            fmt.Printf("回调错误: %v\n", err)
            return
        }
        fmt.Printf("回调结果: %s\n", result)
    })

    // 使用通道
    ch := simulateAsyncWithChannel("input_data_2")
    fmt.Printf("通道结果: %s\n", <-ch)

    time.Sleep(3 * time.Second) // 等待所有Goroutine完成
    fmt.Println("所有操作完成。")
}

package main

import (
    "fmt"
    "sync"
    "time"
)

// performTask 模拟一个耗时同步任务
func performTask(id int) string {
    time.Sleep(time.Duration(id) * 100 * time.Millisecond) // 模拟不同耗时
    return fmt.Sprintf("Task %d completed", id)
}

func main() {
    var wg sync.WaitGroup
    results := make(chan string, 3) // 带缓冲通道，用于收集结果

    tasks := []int{1, 2, 3}

    for _, id := range tasks {
        wg.Add(1)
        go func(taskID int) { // 显式启动Goroutine
            defer wg.Done()
            result := performTask(taskID) // 调用同步函数
            results <- result
        }(id)
    }

    // 启动一个Goroutine来关闭结果通道，确保所有结果被收集后通道能关闭
    go func() {
        wg.Wait()
        close(results)
    }()

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

    fmt.Println("所有任务完成。")
}