package main
import (
 ? "fmt"
 ? "sync"
 ? "time"
)
var group sync.WaitGroup
func sayHello() {
 ? for i := 0; i < 5; i++ {
 ? ? ?fmt.Println("hello......")
 ? ? ?time.Sleep(time.Second)
 ? }
 ? //線程結束 -1
 ? group.Done()
}
func sayHi() {
 ? //線程結束 -1
 ? defer group.Done()
 ? for i := 0; i < 5; i++ {
 ? ? ?fmt.Println("hi......")
 ? ? ?time.Sleep(time.Second)
 ? }
}
func main() {
 ? //+2
 ? group.Add(2)
 ? fmt.Println("main正在阻塞...")
 ? go sayHello()
 ? fmt.Println("main持續(xù)阻塞...")
 ? go sayHi()
 ? //線程等待
 ? group.Wait()
 ? fmt.Println("main貌似結束了阻塞...")
}

func DoSomething(ctx context.Context, arg Arg) error { 
    // ... 使用 ctx ... 
}

//上下文攜帶截止日期、取消信號和請求范圍的值在API的界限。它的方法是安全的同時使用多個了goroutine。
type Context interface {
 ? ?// Done返回一個在上下文被取消或超時時關閉的通道。
 ? ?Done() <-chan struct{}
?
 ? ?// Err表示在Done通道關閉后為何取消此上下文。
 ? ?Err() error
?
 ? ?// Deadline返回上下文將被取消的時間(如果有的話)。
 ? ?Deadline() (deadline time.Time, ok bool)
?
 ? ?// Value返回與key相關的值，如果沒有則返回nil。
 ? ?Value(key interface{}) interface{}
}

//Background返回一個空的Context。 它永遠不會取消，沒有截止日期，沒有價值。 Background通常用于main、init和tests，并作為傳入請求的頂級上下文。 ?
func Background() Context

// WithCancel返回一個父進程的副本，該父進程的Done通道被盡快關閉。?關閉Done或調(diào)用cancel。
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)
// CancelFunc取消一個上下文。
type CancelFunc func()

package main
import (
 ? "context"
 ? "fmt"
)
func play(ctx context.Context) <-chan int {
 ? dist := make(chan int)
 ? n := 1
 ? //匿名函數(shù) 向dist中加入元素
 ? go func() {
 ? ? ?for {
 ? ? ? ? select {
 ? ? ? ? //ctx為空時將不會執(zhí)行這個
 ? ? ? ? case <-ctx.Done():
 ? ? ? ? ? ?return // return結束該goroutine，防止泄露
 ? ? ? ? ? ?//向dist中加入元素
 ? ? ? ? case dist <- n:
 ? ? ? ? ? ?n++
 ? ? ? ? }
 ? ?  }
 ? }()
 ? return dist
}
func main() {
 ? //返回空的context
 ? ctx, cancel := context.WithCancel(context.Background())
 ? defer cancel() // 調(diào)用cancel
 ? for n := range play(ctx) {
 ? ? ?fmt.Println(n)
 ? ? ?if n == 5 {
 ? ? ? ? break
 ? ?  }
 ? }
}

```
select的用法與switch語言非常類似，由select開始一個新的選擇塊，每個選擇條件由case語句來描述。
與switch語句相比， select有比較多的限制，其中最大的一條限制就是每個case語句里必須是一個IO操作，大致的結構如下：
``` go
select {
 ? case <-chan1:
 ? ? ?// 如果chan1成功讀到數(shù)據(jù)，則進行該case處理語句
 ? case chan2 <- 1:
 ? ? ?// 如果成功向chan2寫入數(shù)據(jù)，則進行該case處理語句
 ? default:
 ? ? ?// 如果上面都沒有成功，則進入default處理流程
}
```
在一個select語句中，Go語言會按順序從頭至尾評估每一個發(fā)送和接收的語句。
如果其中的任意一語句可以繼續(xù)執(zhí)行(即沒有被阻塞)，那么就從那些可以執(zhí)行的語句中任意選擇一條來使用。
如果沒有任意一條語句可以執(zhí)行(即所有的通道都被阻塞)，那么有兩種可能的情況：
- 如果給出了default語句，那么就會執(zhí)行default語句，同時程序的執(zhí)行會從select語句后的語句中恢復。
- 如果沒有default語句，那么select語句將被阻塞，直到至少有一個通信可以進行下去。
```

//WithTimeout返回一個父進程的副本，該父進程的Done通道被立即關閉的父母。關閉“完成”、調(diào)用“取消”或超時結束。新
//Context的Deadline是現(xiàn)在的更快+timeout和父的Deadline，如果任何。?如果計時器仍然在運行，則cancel函數(shù)釋放它資源。
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)
// CancelFunc取消一個上下文。
type CancelFunc func()

package main
import (
 ? "context"
 ? "fmt"
 ? "sync"
 ? "time"
)
var wg sync.WaitGroup
func worker(ctx context.Context) {
 ? ?LOOP:
 ? for {
 ? ? ?fmt.Println("db connecting ...")
 ? ? ?time.Sleep(time.Millisecond * 10) // 假設正常連接數(shù)據(jù)庫耗時10毫秒
 ? ? ?select {
 ? ? ?case <-ctx.Done(): // 50毫秒后自動調(diào)用
 ? ? ? ? break LOOP
 ? ? ?default:
 ? ?  }
 ? }
 ? fmt.Println("worker done!")
 ? wg.Done()
}
func main() {
 ? // 設置一個50毫秒的超時
 ? ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
 ? wg.Add(1)
 ? go worker(ctx)
 ? time.Sleep(time.Second * 5)
 ? cancel() // 通知子goroutine結束
 ? wg.Wait()
 ? fmt.Println("over")
}

func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) {
 ? if parent == nil {
 ? ? ?panic("cannot create context from nil parent")
 ? }
 ? if cur, ok := parent.Deadline(); ok && cur.Before(d) {
 ? ? ?// 目前的期限已經(jīng)比新的期限提前
 ? ? ?return WithCancel(parent)
 ? }
 ? c := &timerCtx{
 ? ? ?cancelCtx: newCancelCtx(parent),
 ? ? ?deadline: ?d,
 ? }
 ? propagateCancel(parent, c)
 ? dur := time.Until(d)
 ? if dur <= 0 {
 ? ? ?c.cancel(true, DeadlineExceeded) // 截止日期已經(jīng)過去了
 ? ? ?return c, func() { c.cancel(false, Canceled) }
 ? }
 ? c.mu.Lock()
 ? defer c.mu.Unlock()
 ? if c.err == nil {
 ? ? ?c.timer = time.AfterFunc(dur, func() {
 ? ? ? ? c.cancel(true, DeadlineExceeded)
 ? ?  })
 ? }
 ? return c, func() { c.cancel(true, Canceled) }
}

package main
import (
 ? "context"
 ? "fmt"
 ? "time"
)
func main() {
 ? d := time.Now().Add(500 * time.Millisecond)
 ? ctx, cancel := context.WithDeadline(context.Background(), d)
 ? // 盡管ctx會過期，但在任何情況下調(diào)用它的cancel函數(shù)都是很好的實踐。
 ? // 如果不這樣做，可能會使上下文及其父類存活的時間超過必要的時間。
 ? defer cancel()
 ? select {
 ? case <-time.After(1 * time.Second):
 ? ? ?fmt.Println("over")
 ? case <-ctx.Done():
 ? ? ?fmt.Println(ctx.Err())
 ? }
}

//WithValue返回父元素的副本，其Value方法返回val for key。
func WithValue(parent Context, key interface{}, val interface{}) Context

package main
import (
 ? "context"
 ? "fmt"
 ? "sync"
 ? "time"
)
type TraceCode string
var wg sync.WaitGroup
func worker(ctx context.Context) {
 ? key := TraceCode("KEY_CODE")
 ? traceCode, ok := ctx.Value(key).(string) // 在子goroutine中獲取trace code
 ? if !ok {
 ? ? ?fmt.Println("invalid trace code")
 ? }
 ? ?LOOP:
 ? for {
 ? ? ?fmt.Printf("worker,code:%s\n", traceCode)
 ? ? ?time.Sleep(time.Millisecond * 10) // 假設正常連接數(shù)據(jù)庫耗時10毫秒
 ? ? ?select {
 ? ? ?case <-ctx.Done(): // 50毫秒后自動調(diào)用
 ? ? ? ? break LOOP
 ? ? ?default:
 ? ?  }
 ? }
 ? fmt.Println("worker is over!")
 ? wg.Done()
}
?
func main() {
 ? // 設置一個50毫秒的超時
 ? ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*50)
 ? // 在系統(tǒng)的入口中設置trace code傳遞給后續(xù)啟動的goroutine實現(xiàn)日志數(shù)據(jù)聚合
 ? ctx = context.WithValue(ctx, TraceCode("KEY_CODE"), "12512312234")
 ? wg.Add(1)
 ? go worker(ctx)
 ? time.Sleep(time.Second * 5)
 ? cancel() // 通知子goroutine結束
 ? wg.Wait()
 ? fmt.Println("over")
}

package main
import (
 ? "fmt"
 ? "math/rand"
 ? "net/http"
 ? "time"
)
// server端，隨機出現(xiàn)慢響應
func indexHandler(w http.ResponseWriter, r *http.Request) {
 ? number := rand.Intn(2)
 ? if number == 0 {
 ? ? ?time.Sleep(time.Second * 10) // 耗時10秒的慢響應
 ? ? ?fmt.Fprintf(w, "slow response")
 ? ? ?return
 ? }
 ? fmt.Fprint(w, "quick response")
}
func main() {
 ? http.HandleFunc("/", indexHandler)
 ? err := http.ListenAndServe(":9999", nil)
 ? if err != nil {
 ? ? ?panic(err)
 ? }
}

package main
import (
 ? "context"
 ? "fmt"
 ? "io/ioutil"
 ? "net/http"
 ? "sync"
 ? "time"
)
// 客戶端
?
type respData struct {
 ? resp *http.Response
 ? err ?error
}
func doCall(ctx context.Context) {
 ? // http長連接
 ? transport := http.Transport{DisableKeepAlives: true}
 ? client := http.Client{Transport: &transport}
?
 ? respChan := make(chan *respData, 1)
 ? req, err := http.NewRequest("GET", "http://127.0.0.1:9999/", nil)
 ? if err != nil {
 ? ? ?fmt.Println(err)
 ? ? ?return
 ? }
 ? req = req.WithContext(ctx) // 使用帶超時的ctx創(chuàng)建一個新的client request
 ? var wg sync.WaitGroup
 ? wg.Add(1)
 ? defer wg.Wait()
 ? go func() {
 ? ? ?resp, err := client.Do(req)
 ? ? ?fmt.Printf("resp:%v, err:%v\n", resp, err)
 ? ? ?rd := &respData{
 ? ? ? ? resp: resp,
 ? ? ? ? err: ?err,
 ? ?  }
 ? ? ?respChan <- rd
 ? ? ?wg.Done()
 ? }()
 ? select {
 ? case <-ctx.Done():
 ? ? ?fmt.Println("timeout...")
 ? case result := <-respChan:
 ? ? ?fmt.Println("success....")
 ? ? ?if result.err != nil {
 ? ? ? ? fmt.Printf("err:%v\n", result.err)
 ? ? ? ? return
 ? ?  }
 ? ? ?defer result.resp.Body.Close()
 ? ? ?data, _ := ioutil.ReadAll(result.resp.Body)
 ? ? ?fmt.Printf("resp:%v\n", string(data))
 ? }
}
?
func main() {
 ? // 定義一個100毫秒的超時
 ? ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
 ? defer cancel() // 調(diào)用cancel釋放子goroutine資源
 ? doCall(ctx)
}