超时表象

package main

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

func main() {
    ctx, cancle := context.WithTimeout(context.Background(), time.Second*5)
    defer cancle()
    fmt.Println("<<<<<<<<<<<<<<<<", T2(ctx))

}

func T(ctx context.Context) []int {
    c := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            c <- i
            time.Sleep(1 * time.Second)
        }
        close(c)
    }()
    result := make([]int, 0)
    for {
        var (
            ok bool
            x  int
        )
        select {
        case x, ok = <-c:
            fmt.Println(">>>>>>>>>>>", x)
            result = append(result, x)
        case <-ctx.Done():
            fmt.Println(">>>>>>>>>timeout")
        }
        if !ok {
            break
        }
    }
    return result
}

func T2(ctx context.Context) []int {
    c := make(chan error)
    result := make([]int, 0)
    go func() {
        defer close(c)

        for i := 0; i < 10; i++ {
            result = append(result, i)
            c <- errors.New("hahahah")
            time.Sleep(1 * time.Second)
        }
    }()
    for {
        select {
        case x, ok := <-c:
            fmt.Println(">>>>>>>", x)
            if !ok {
                return result
            }
        case <-ctx.Done():
            fmt.Println(">>>>>>>>>timeout")
            return result
        }
    }
}

func T3() []int {
    c := make(chan error)
    result := make([]int, 0)
    go func() {
        defer close(c)

        for i := 0; i < 10; i++ {
            result = append(result, i)
            c <- errors.New("hahahah")
            time.Sleep(1 * time.Second)
        }
    }()
    for {
        select {
        case x, ok := <-c:
            fmt.Println(">>>>>>>", x)
            if !ok {
                return result
            }
        case <-time.After(time.Second * 5):
            fmt.Println(">>>>>>>>>timeout")
            return result
        }
    }
}

func T4() []int {
    c := make(chan error)
    result := make([]int, 0)
    go func() {
        defer close(c)
        for i := 0; i < 10; i++ {
            result = append(result, i)
            c <- errors.New("hahahah")
            time.Sleep(6 * time.Second)
        }
    }()
    for {
        select {
        case x, ok := <-c:
            fmt.Println(">>>>>>>", x)
            if !ok {
                return result
            }
        case <-time.After(time.Second * 5):
            fmt.Println(">>>>>>>>>timeout")
            return result
        }
    }
}

func T5() []int {
    c := make(chan error)
    result := make([]int, 0)
    go func() {
        defer close(c)
        for i := 0; i < 10; i++ {
            result = append(result, i)
            c <- errors.New("hahahah")
            time.Sleep(6 * time.Second)
        }
    }()
    for timeOut := time.After(time.Second * 20); ; {
        select {
        case x, ok := <-c:
            fmt.Println(">>>>>>>", x)
            if !ok {
                return result
            }
        case <-timeOut:
            fmt.Println(">>>>>>>>>timeout")
            return result
        }
    }
}