Go并发编程：优雅地取消Goroutine与超时处理

func WaitForStringOrTimeout() (string, error) {
    myChannel := make(chan string)
    go func() {
        // 模拟一个可能长时间阻塞的操作
        // WaitForString(myChannel)
        time.Sleep(20 * time.Minute) // 假设这里是实际的阻塞操作
        myChannel <- "found string"
    }()

    select {
    case foundString := <-myChannel:
        return foundString, nil
    case <-time.After(15 * time.Minute):
        return "", errors.New("Timed out waiting for string")
    }
}

import (
    "errors"
    "fmt"
    "time"
)

func WaitForStringOrTimeoutOptimized() (string, error) {
    myChannel := make(chan string)
    go func() {
        // 模拟一个可能长时间阻塞的操作
        // WaitForString(myChannel)
        time.Sleep(20 * time.Minute) // 假设这里是实际的阻塞操作
        myChannel <- "found string"
    }()

    timer := time.NewTimer(15 * time.Minute)
    defer timer.Stop() // 确保在函数返回前停止定时器，释放资源

    select {
    case foundString := <-myChannel:
        return foundString, nil
    case <-timer.C: // 从timer.C接收超时信号
        return "", errors.New("Timed out waiting for string")
    }
}

func main() {
    // 示例调用
    // result, err := WaitForStringOrTimeoutOptimized()
    // if err != nil {
    //     fmt.Println("Error:", err)
    // } else {
    //     fmt.Println("Result:", result)
    // }
}

import (
    "context"
    "fmt"
    "time"
)

// Worker simulates a long-running task that respects cancellation.
func Worker(ctx context.Context, id int) {
    fmt.Printf("Worker %d started\n", id)
    for {
        select {
        case <-ctx.Done(): // 检查取消信号
            fmt.Printf("Worker %d received cancellation signal. Exiting.\n", id)
            return
        case <-time.After(1 * time.Second): // 模拟工作负载
            fmt.Printf("Worker %d working...\n", id)
        }
    }
}

func main() {
    // 创建一个可取消的上下文
    ctx, cancel := context.WithCancel(context.Background())

    // 启动一个Worker Goroutine
    go Worker(ctx, 1)

    // 让Worker运行一段时间
    time.Sleep(3 * time.Second)

    // 发送取消信号
    fmt.Println("Main: Sending cancellation signal...")
    cancel() // 调用cancel函数会关闭ctx.Done()通道

    // 等待Worker退出
    time.Sleep(1 * time.Second)
    fmt.Println("Main: Program finished.")
}

import (
    "context"
    "fmt"
    "time"
)

// FetchData simulates fetching data from a remote service with a context.
func FetchData(ctx context.Context) (string, error) {
    select {
    case <-time.After(2 * time.Second): // 模拟数据获取时间
        return "Data fetched successfully", nil
    case <-ctx.Done(): // 检查上下文是否被取消或超时
        return "", ctx.Err() // 返回上下文的错误（如context.DeadlineExceeded）
    }
}

func main() {
    // 创建一个带有5秒超时的上下文
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel() // 最佳实践：即使超时，也要调用cancel()以释放资源

    fmt.Println("Main: Starting data fetch with 5s timeout...")
    data, err := FetchData(ctx)
    if err != nil {
        fmt.Printf("Main: Error fetching data: %v\n", err)
    } else {
        fmt.Printf("Main: Data: %s\n", data)
    }

    // 模拟一个更短的超时，导致FetchData超时
    ctx2, cancel2 := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel2()

    fmt.Println("\nMain: Starting data fetch with 1s timeout...")
    data2, err2 := FetchData(ctx2)
    if err2 != nil {
        fmt.Printf("Main: Error fetching data: %v\n", err2)
    } else {
        fmt.Printf("Main: Data: %s\n", data2)
    }
}