Go语言Context应用全攻略：异步编程利器

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

package main
import (  "context"  "fmt"  "time")
func main() {  // 创建一个根Context  rootContext := context.Background()
  // 创建一个带有超时时间的Context，这里设置超时时间为2秒  ctx, cancel := context.WithTimeout(rootContext, 2*time.Second)  defer cancel()
  // 在新的goroutine中执行任务  go func(ctx context.Context) {    select {    case <-time.After(3 * time.Second):      fmt.Println("任务完成")    case <-ctx.Done():      fmt.Println("任务取消或超时")    }  }(ctx)    // 等待一段时间，模拟程序运行  time.Sleep(5 * time.Second)}‍

package main
import (  "context"  "fmt")
type key string
func main() {  // 创建一个根Context  rootContext := context.Background()
  // 使用WithValue传递数据  ctx := context.WithValue(rootContext, key("userID"), 123)
  // 在子函数中获取传递的数据  getUserID(ctx)}
func getUserID(ctx context.Context) {  // 从Context中获取数据  if userID, ok := ctx.Value(key("userID")).(int); ok {    fmt.Println("UserID:", userID)  } else {    fmt.Println("UserID不存在")  }}

package main
import (  "context"  "fmt"  "time")
func main() {  // 创建一个根Context  rootContext := context.Background()
  // 创建一个超时时间为2秒的Context  timeoutCtx, _ := context.WithTimeout(rootContext, 2*time.Second)
  // 创建一个手动取消的Context  cancelCtx, cancel := context.WithCancel(rootContext)  defer cancel()
  // 在新的goroutine中执行任务  go func(ctx context.Context) {    select {    case <-time.After(3 * time.Second):      fmt.Println("任务完成")    case <-ctx.Done():      fmt.Println("任务取消或超时")    }  }(timeoutCtx)
  // 在另一个goroutine中执行任务  go func(ctx context.Context) {    select {    case <-time.After(1 * time.Second):      fmt.Println("另一个任务完成")    case <-ctx.Done():      fmt.Println("另一个任务取消")    }  }(cancelCtx)
  // 等待一段时间，模拟程序运行  time.Sleep(5 * time.Second)}

package main
import (  "context"  "fmt"  "time")
func main() {  // 创建一个根Context  rootContext := context.Background()
  // 创建一个可以手动取消的Context  ctx, cancel := context.WithCancel(rootContext)  defer cancel()
  // 在新的goroutine中执行任务  go func(ctx context.Context) {    select {    case <-time.After(3 * time.Second):      fmt.Println("任务完成")    case <-ctx.Done():      fmt.Println("任务取消")    }  }(ctx)
  // 等待一段时间，手动取消任务  time.Sleep(2 * time.Second)  cancel()
  // 等待一段时间，模拟程序运行  time.Sleep(1 * time.Second)}

package main
import (  "context"  "fmt"  "time")
func main() {  // 创建一个根Context  rootContext := context.Background()
  // 创建一个超时时间为2秒的Context  timeoutCtx, _ := context.WithTimeout(rootContext, 2*time.Second)
  // 创建一个手动取消的Context  cancelCtx, cancel := context.WithCancel(rootContext)  defer cancel()
  // 在新的goroutine中执行任务  go func(ctx context.Context) {    select {    case <-time.After(3 * time.Second):      fmt.Println("任务完成")    case <-ctx.Done():      fmt.Println("任务取消或超时")    }  }(timeoutCtx)
  // 在另一个goroutine中执行任务  go func(ctx context.Context) {    select {    case <-time.After(1 * time.Second):      fmt.Println("另一个任务完成")    case <-ctx.Done():      fmt.Println("另一个任务取消")    }  }(cancelCtx)
  // 等待一段时间，模拟程序运行  time.Sleep(5 * time.Second)}

package main
import (  "context"  "fmt"  "sync"  "time")
func main() {  // 创建一个根Context  rootContext := context.Background()
  // 创建一个可以手动取消的Context  ctx, cancel := context.WithCancel(rootContext)  defer cancel()
  // 使用WaitGroup等待所有任务完成  var wg sync.WaitGroup
  // 启动多个协程执行任务  for i := 0; i < 5; i++ {    wg.Add(1)    go func(id int) {      defer wg.Done()      select {      case <-time.After(time.Duration(id) * time.Second):        fmt.Println("任务", id, "完成")      case <-ctx.Done():        fmt.Println("任务", id, "取消")      }    }(i)  }
  // 等待一段时间，然后手动取消任务  time.Sleep(2 * time.Second)  cancel()
  // 等待所有任务完成  wg.Wait()}

package main
import (  "fmt"  "net/http"  "time")
func handler(w http.ResponseWriter, r *http.Request) {  ctx := r.Context()
  select {  case <-time.After(2 * time.Second):    fmt.Fprintln(w, "Hello, World!")  case <-ctx.Done():    err := ctx.Err()    fmt.Println("Server:", err)    http.Error(w, err.Error(), http.StatusInternalServerError)  }}
func main() {  http.HandleFunc("/", handler)  http.ListenAndServe(":8080", nil)}

package main
import (  "context"  "database/sql"  "fmt"  "time"
  _ "github.com/go-sql-driver/mysql")
func main() {  // 连接数据库  db, err := sql.Open("mysql", "username:password@tcp(localhost:3306)/database")  if err != nil {    fmt.Println("数据库连接失败:", err)    return  }  defer db.Close()
  // 创建一个Context，设置超时时间为5秒  ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)  defer cancel()
  // 在Context的超时时间内执行数据库查询  rows, err := db.QueryContext(ctx, "SELECT * FROM users")  if err != nil {    fmt.Println("数据库查询失败:", err)    return  }  defer rows.Close()
  // 处理查询结果  for rows.Next() {    // 处理每一行数据  }}

package main
import (  "context"  "fmt"  "time")
type Request struct {  ID int}
type Response struct {  Message string}
func microservice(ctx context.Context, reqCh chan Request, resCh chan Response) {  for {    select {    case <-ctx.Done():      fmt.Println("Microservice shutting down...")      return    case req := <-reqCh:      // 模拟处理请求的耗时操作      time.Sleep(2 * time.Second)      response := Response{Message: fmt.Sprintf("Processed request with ID %d", req.ID)}      resCh <- response    }  }}
func main() {  // 创建根Context  rootContext := context.Background()
  // 创建用于请求和响应的通道  reqCh := make(chan Request)  resCh := make(chan Response)
  // 启动微服务  go microservice(rootContext, reqCh, resCh)
  // 创建带有5秒超时时间的Context  ctx, cancel := context.WithTimeout(rootContext, 5*time.Second)  defer cancel()
  // 发送请求到微服务  for i := 1; i <= 3; i++ {    req := Request{ID: i}    reqCh <- req
    select {    case <-ctx.Done():      fmt.Println("Request timed out!")      return    case res := <-resCh:      fmt.Println(res.Message)    }  }}