Go并发编程中Goroutine的终止、超时处理与资源管理

func WaitForStringOrTimeout() (string, error) {
  myChannel := make(chan string)
  go WaitForString(myChannel) // 假设WaitForString会向myChannel发送字符串

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

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

// 模拟一个可能阻塞的函数
func WaitForString(ch chan string) {
    // 模拟一些工作，可能很快完成，也可能一直阻塞
    time.Sleep(2 * time.Second) // 假设2秒后发送
    ch <- "Hello Go!"
}

func WaitForStringOrTimeoutOptimized() (string, error) {
    myChannel := make(chan string)
    go WaitForString(myChannel)

    t := time.NewTimer(5 * time.Second) // 创建一个5秒的计时器
    defer t.Stop()                     // 确保函数退出时停止计时器

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

func main() {
    // 示例1: 成功获取字符串
    result, err := WaitForStringOrTimeoutOptimized()
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result) // 预期输出: Result: Hello Go!
    }

    // 示例2: 模拟超时 (将WaitForString的sleep时间延长，或NewTimer时间缩短)
    // 为了演示超时，我们调整一下WaitForString的模拟时间
    // func WaitForString(ch chan string) { time.Sleep(10 * time.Second); ch <- "Hello Go!" }
    // 或者，这里为了演示，直接再次调用，并假设第一次的WaitForString已经结束
    // 实际应用中，如果WaitForString是独立的，需要重新启动
    myChannel2 := make(chan string)
    go func() {
        time.Sleep(10 * time.Second) // 模拟一个长时间阻塞的goroutine
        myChannel2 <- "Too late"
    }()

    t2 := time.NewTimer(3 * time.Second) // 设置一个更短的超时
    defer t2.Stop()

    select {
    case foundString := <-myChannel2:
        fmt.Println("Result (should not happen):", foundString)
    case <-t2.C:
        fmt.Println("Result (timeout): Timed out waiting for string") // 预期输出: Result (timeout): Timed out waiting for string
    }
}

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

// WaitForStringContext 接收一个context，并在超时或取消时停止工作
func WaitForStringContext(ctx context.Context, ch chan string) {
    select {
    case <-time.After(5 * time.Second): // 模拟一些长时间的工作
        // 正常完成工作
        select {
        case ch <- "Hello from Context!":
        case <-ctx.Done():
            // 如果在发送前context被取消了，则不发送
            fmt.Println("WaitForStringContext: Context cancelled before sending result.")
        }
    case <-ctx.Done():
        // context被取消，Goroutine应立即退出
        fmt.Println("WaitForStringContext: Context cancelled, exiting.")
        return
    }
}

func WaitForStringOrTimeoutWithContext() (string, error) {
    myChannel := make(chan string)

    // 创建一个带有5秒超时的context
    ctx, cancel := context.WithTimeout(context.Background(), 3 * time.Second)
    defer cancel() // 确保在函数退出时取消context，释放资源

    go WaitForStringContext(ctx, myChannel)

    select {
    case foundString := <-myChannel:
        return foundString, nil
    case <-ctx.Done(): // 监听context的Done通道
        // context被取消，可能是超时，也可能是外部cancel()调用
        return "", errors.New("Operation timed out or was cancelled")
    }
}

func main() {
    result, err := WaitForStringOrTimeoutWithContext()
    if err != nil {
        fmt.Println("Main Error:", err) // 预期输出: Main Error: Operation timed out or was cancelled
    } else {
        fmt.Println("Main Result:", result)
    }

    // 演示Goroutine正常完成前Context被取消
    ctxCancel, cancelFunc := context.WithCancel(context.Background())
    myChannel3 := make(chan string)
    go func() {
        // 模拟一个更长的操作，但我们会在它完成前取消
        time.Sleep(5 * time.Second)
        select {
        case myChannel3 <- "Long operation result":
        case <-ctxCancel.Done():
            fmt.Println("Long operation: Context cancelled before sending result.")
        }
    }()

    go func() {
        time.Sleep(1 * time.Second) // 1秒后主动取消
        cancelFunc()
    }()

    select {
    case res := <-myChannel3:
        fmt.Println("Received result:", res)
    case <-ctxCancel.Done():
        fmt.Println("Main: Context was cancelled.") // 预期输出: Main: Context was cancelled.
    }
    time.Sleep(100 * time.Millisecond) // 给Goroutine一点时间打印消息
}