您可以使用select来实现这一点：

package main
import (
    "fmt"
    "time"
    "context"
)
func main() {
    fmt.Println("Hello, playground")
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    go func(){
        t := time.Now()
        select{
        case <-ctx.Done(): //context cancelled
        case <-time.After(2 * time.Second): //timeout
        }
        fmt.Printf("here after: %v\n", time.Since(t))
    }()
    cancel() //cancel manually, comment out to see timeout kick in
    time.Sleep(3 * time.Second)
    fmt.Println("done")
}

字符串
这里是Go-playground link

你可以像其他人提到的那样使用select;但是，其他答案有一个bug，因为如果不清理timer.After()，它会泄漏内存。

func SleepWithContext(ctx context.Context, d time.Duration) {
    timer := time.NewTimer(d)
    select {
    case <-ctx.Done():
        if !timer.Stop() {
            <-timer.C
        }
    case <-timer.C:
    }
}

字符串

下面是一个sleepContext函数，你可以用它来代替time.Sleep：

func sleepContext(ctx context.Context, delay time.Duration) {
    select {
    case <-ctx.Done():
    case <-time.After(delay):
    }
}

字符串
以下是一些示例用法（full runnable code on the Go Playground）：

func main() {
    ctx := context.Background()
    fmt.Println(time.Now())
    sleepContext(ctx, 1*time.Second)
    fmt.Println(time.Now())
    ctxTimeout, cancel := context.WithTimeout(ctx, 500*time.Millisecond)
    sleepContext(ctxTimeout, 1*time.Second)
    cancel()
    fmt.Println(time.Now())
}

型

time.After()函数存在以下问题：
在计时器触发之前，垃圾回收器不会恢复基础计时器。如果需要考虑效率，请改用NewTimer并调用Timer。如果不再需要计时器，请停止。
最好使用Timer对象并调用Stop()：

// Delay returns nil after the specified duration or error if interrupted.
func Delay(ctx context.Context, d time.Duration) error {
    t := time.NewTimer(d)
    select {
    case <-ctx.Done():
        t.Stop()
        return fmt.Errorf("Interrupted")
    case <-t.C:
    }
    return nil
}

字符串

我通过将CancelContext和TimeoutContext结合起来做了类似的事情。
下面是示例代码：

cancelCtx, cancel := context.WithCancel(context.Background())
defer cancel()
// The program "sleeps" for 5 seconds.
timeoutCtx, _ := context.WithTimeout(cancelCtx, 5*time.Second)
select {
case <-timeoutCtx.Done():
    if cancelCtx.Err() != nil {
        log.Printf("Context cancelled")
    }
}

字符串
在this repo中你可以找到上述代码的完整用法。对不起，我的回答很简短，我还没有打开电脑，从电话上回答并不容易。

根据您的使用情况，select{}是不需要的。

sleep, cancel := context.WithTimeout(ctx, time.Second*5)
defer cancel()
<-sleep.Done()

字符串
<-sleep.Done()等待5秒或直到父ctx被取消，以先发生者为准。