select {
 case res := <-c2:
  fmt.Println(res)
 case <-time.After(time.Second * 3):
  fmt.Println("timeout 2")
 }

func After(d Duration) <-chan Time {
 return NewTimer(d).C
}

package timeout

import (
 "fmt"
 "testing"
 "time"
)

func TestSelectTimeOut(t *testing.T) {
 // 在這個(gè)例子中， 假設(shè)我們執(zhí)行了一個(gè)外部調(diào)用， 2秒之后將結(jié)果寫(xiě)入c1
 c1 := make(chan string, 1)
 go func() {
  time.Sleep(time.Second * 2)
  c1 <- "result 1"
 }()
 // 這里使用select來(lái)實(shí)現(xiàn)超時(shí)， `res := <-c1`等待通道結(jié)果，
 // `<- Time.After`則在等待1秒后返回一個(gè)值， 因?yàn)閟elect首先
 // 執(zhí)行那些不再阻塞的case， 所以這里會(huì)執(zhí)行超時(shí)程序， 如果
 // `res := <-c1`超過(guò)1秒沒(méi)有執(zhí)行的話
 select {
 case res := <-c1:
  fmt.Println(res)
 case <-time.After(time.Second * 1):
  fmt.Println("timeout 1")
 }
 // 如果我們將超時(shí)時(shí)間設(shè)為3秒， 這個(gè)時(shí)候`res := <-c2`將在
 // 超時(shí)case之前執(zhí)行， 從而能夠輸出寫(xiě)入通道c2的值
 c2 := make(chan string, 1)
 go func() {
  time.Sleep(time.Second * 2)
  c2 <- "result 2"
 }()
 select {
 case res := <-c2:
  fmt.Println(res)
 case <-time.After(time.Second * 3):
  fmt.Println("timeout 2")
 }
}

package main
import "time"
import "fmt"
func main() {
  // Ticker使用和Timer相似的機(jī)制， 同樣是使用一個(gè)通道來(lái)發(fā)送數(shù)據(jù)。
  // 這里我們使用range函數(shù)來(lái)遍歷通道數(shù)據(jù)， 這些數(shù)據(jù)每隔500毫秒被
  // 發(fā)送一次， 這樣我們就可以接收到
  ticker := time.NewTicker(time.Millisecond * 500)
  go func() {
    for t := range ticker.C {
    fmt.Println("Tick at", t)
    }
  }()
  // Ticker和Timer一樣可以被停止。 一旦Ticker停止后， 通道將不再
  // 接收數(shù)據(jù)， 這里我們將在1500毫秒之后停止
  time.Sleep(time.Millisecond * 1500)
  ticker.Stop()
  fmt.Println("Ticker stopped")
}

  go func(ctx context.Context, info *Info) {
   timeLimit := 120
   timeoutCtx, cancel := context.WithTimeout(ctx, time.Duration(timeLimit)*time.Millisecond)
   defer func() {
    cancel()
    wg.Done()
   }()
   resp := DoHttp(timeoutCtx, info.req)
  }(ctx, info)

req, err := http.NewRequestWithContext(ctx, "POST", url, strings.NewReader(paramString))

package main

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

func TestTimerContext(t *testing.T) {
 now := time.Now()
 later, _ := time.ParseDuration("10s")

 ctx, cancel := context.WithDeadline(context.Background(), now.Add(later))
 defer cancel()
 go Monitor(ctx)

 time.Sleep(20 * time.Second)

}

func Monitor(ctx context.Context) {
 select {
 case <-ctx.Done():
  fmt.Println(ctx.Err())
 case <-time.After(20 * time.Second):
  fmt.Println("stop monitor")
 }
}

type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key interface{}) interface{}
}