• Golang基础7-并发编程

    并发编程

    https://www.cnblogs.com/Survivalist/p/11527949.html

    进程和线程、协程的区别_线程协程进程的区别-CSDN博客

    Golang中的并发编程是一个重点，我们要了解Golang中的并发Goroutine因此需要先理解进程、线程、之后再理解协程。

    进程：操作系统进行资源分配的最小单元，是程序在执行过程中的一次活动，包括程序，数据集合，程序控制块(PCB)等。每个进程都有独立的内存空间，包括代码、数据、堆栈，因此进程之间相互隔离。进程切换开销大(包括栈、寄存器、页表、文件句柄等切换)。尽管更安全，但也占据了较多系统资源

    线程：操作系统进行调度的最小单元，是进程中执行的基本单元，由线程ID，当前指令指针PC，寄存器和堆栈组成。一个进程包含>=1个线程，其中一个为主线程，多个线程时通过共享内存，上下文切换较快，资源开销较小。共享内存尤其需要注意线程同步互斥问题。

    协程：用户轻量级线程，由程序控制，不被操作系统内核管理

    更轻量，独立栈空间(协程之间不共享内存，但是可以通信(channel)进行交互)，更易并发(高效切换无需过多锁)

    并行和并发区别

    goroutine

    参考文章：Goroutine · Golang 学习笔记

    每个goroutine是官方实现的超级"线程池"

    每个实例4-5KB栈内存和实现机制大幅减少创建和销毁使得go更易实现高并发

    goroutine奉行通信(配合channel)实现共享内存。

    在go语言层面内置调度和上下文切换机制，并且go程序会智能地将任务合理的分配给CPU

    简单demo
    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "time"
    6. )
    7.  
    8. func Hello() {
    9.     fmt.Println("Hello Function!")
    10. }
    11.  
    12. func main() {
    13.     //在函数前加入关键字go
    14.     go Hello()
    15.     fmt.Println("Main done")
    16.     //休眠,等go Hello()执行完
    17.     time.Sleep(time.Second)
    18. }

    sync.WaitGroup demo
    1. WaitGroup用来启动一组goroutine，等待任务做完再结束goroutine。
    2. wg.Add(delta int):设置将要启动的Goroutine的数量，来设置WaitGroup内部计数器
    3. wg.Done():每个goroutine完成后，计数器-1 ;对于可能panic的可以使用defer wg.Done()
    4. wg.Wait():阻塞自己，等待所有goroutine完成任务，计数器减为0，返回

    sync.WaitGroup中的Add和Done线程安全，可以从多个groutine中调用这两个方法，不用担心数据竞争和其他并发问题。

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6. )
    7. //启动多个goroutine
    8. func main() {
    9.     //协程同步
    10.     var wg sync.WaitGroup
    11.     wg.Add(9)
    12.  
    13.     for i := 0; i < 9; i++ {
    14.         //当作参数传入会拷贝一份，因此可以保证输出0-8
    15.         go func(i int) {
    16.             defer  wg.Done()
    17.             fmt.Printf("%d ",i)
    18.         }(i)
    19.     }
    20.     // 阻塞主程序，等待所有 Goroutine 完成
    21.     wg.Wait()
    22. }

    输出结构并发乱序。0-9的其中一个组合

    sync.Map demo
      1. sync.Map并发安全的sync.Map，可以安全并发的读写操作，常见操作见代码
      2. 与之相对应的原生map，线程不安全，并发读写时需要加锁
    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6. )
    7.  
    8. func main() {
    9.     //sync.Map的key和value都是interface{}
    10.     var m sync.Map
    11.  
    12.     //写入
    13.     m.Store("1", 18)
    14.     m.Store("2", 20)
    15.  
    16.     //读取
    17.     age, ok := m.Load("1")
    18.     if ok {
    19.         fmt.Println("读取成功", age, ok)
    20.     } else {
    21.         fmt.Println("读取失败！")
    22.     }
    23.  
    24.     //遍历!!
    25.     m.Range(func(key, value interface{}) bool {
    26.         fmt.Println("遍历：key=", key, " value=", value)
    27.         return true
    28.     })
    29.  
    30.     //根据key删除
    31.     m.Delete("2")
    32.     age, ok = m.Load("2")
    33.     if ok {
    34.         fmt.Println("删除后读取成功", age, ok)
    35.     } else {
    36.         fmt.Println("删除后读取失败！")
    37.     }
    38.  
    39.     //存在则读取否则写入
    40.     //如果存在key=2,ok返回为true,否则false
    41.     age, ok = m.LoadOrStore("2", "100")
    42.     if ok {
    43.         fmt.Println("已存在的:", age)
    44.     } else {
    45.         fmt.Println("不存在，store后的:", age)
    46.     }
    47.  
    48. }

    map并发 demo
      • 原生map实现并发时一定需要加锁来保证安全，不然报错。
      • sync.Map安全Map，不需要上锁解锁操作。
    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6. )
    7.  
    8. func main() {
    9.     //没有加锁的并发写入，则会报错
    10.     m := make(map[int]int)
    11.  
    12.     var wg sync.WaitGroup
    13.     var mu sync.Mutex
    14.  
    15.     for i := 0; i < 9; i++ {
    16.         wg.Add(1)
    17.  
    18.         go func(i int) {
    19.             for j := 0; j < 9; j++ {
    20.                 //上锁
    21.                 mu.Lock()
    22.                 m[j] = i
    23.                 mu.Unlock()
    24.             }
    25.             wg.Done()
    26.         }(i)
    27.  
    28.     }
    29.     
    30.  
    31.     //    安全Map
    32.     var sm sync.Map
    33.     for i := 0; i < 9; i++ {
    34.         wg.Add(1)
    35.         go func(i int) {
    36.             for j := 0; j < 9; j++ {
    37.                 sm.Store(j, i)
    38.             }
    39.             wg.Done()
    40.         }(i)
    41.  
    42.     }
    43.     //完成前面并发任务后输出
    44.     wg.Wait()
    45.     
    46.     fmt.Println("最终打印map值：", m)
    47.     fmt.Print("最终打印sync.Map值：")
    48.     sm.Range(func(key, value interface{}) bool {
    49.         fmt.Printf("%d:%d ", key, value)
    50.         return true
    51.     })
    52.  
    53. }

    go的GMP调度原理

    channel

    go中不要通过共享内存来通信，而是通过通信来共享内存。

    参考：Go Channel 详解

    go高性能编程：GitHub - wuqinqiang/Go_Concurrency: go concurrency class code

    go语言核心类型，管道，并发中可以进行发送或接收数据进行通信。

    <-

    使用make创建channel，chan底层是一个环形数组

    类型：chan chan <- <-chan

    使用场景：

      • 消息传递、消息过滤
      • 信号广播
      • 事件的订阅和广播
      • 任务分发
      • 结果汇总
      • 并发控制
      • 同步和异步

    简单demo

    无缓冲channel（B要第一时间知道A是否完成）、有缓冲channel（生产者消费者模型）

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6. )
    7.  
    8. func main() {
    9.     c := make(chan int, 2)
    10.     defer close(c)
    11.  
    12.     var wg sync.WaitGroup
    13.  
    14.     wg.Add(1)
    15.  
    16.     go func() {
    17.         defer wg.Done()
    18.         c <- 3 + 4
    19.         c <- 1
    20.         fmt.Println("发送成功")
    21.     }()
    22.  
    23.     wg.Add(1)
    24.     go func() {
    25.         defer wg.Done()
    26.         c <- 100
    27.     }()
    28.     
    29.     //wg.Wait()
    30.     i := <-c
    31.     j := <-c
    32.     _ = <-c//忽略这个值
    33.     fmt.Println(i, j)
    34.  
    35.     wg.Wait()
    36.  
    37. }

    1. import "fmt"
    2. func sum(s []int, c chan int) {
    3.     sum := 0
    4.     for _, v := range s {
    5.         sum += v
    6.     }
    7.     c <- sum // send sum to c
    8. }
    9. func main() {
    10.     s := []int{7, 2, 8, -9, 4, 0}
    11.     c := make(chan int)
    12.     go sum(s[:len(s)/2], c)
    13.     go sum(s[len(s)/2:], c)
    14.     x, y := <-c, <-c // receive from c
    15.     fmt.Println(x, y, x+y)
    16. }

    channel的range

    1. func main() {
    2.     go func() {
    3.         time.Sleep(1 * time.Hour)
    4.     }()
    5.     c := make(chan int)
    6.     go func() {
    7.         for i := 0; i < 10; i = i + 1 {
    8.             c <- i
    9.         }
    10.         close(c)
    11.     }()
    12.     for i := range c {
    13.         fmt.Println(i)
    14.     }
    15.     fmt.Println("Finished")
    16. }

    这个range会一直从c中获取，直到c关闭

    select demo

    类似与linux中io的select、poll、epoll。

    select语句类似于switch，随机执行一个可执行的case，select只用于通信操作，如果没有case可运行那么将阻塞，直到有case可运行。默认的字句总是可以运行。

      • 每个case都必须是一个通信
      • 所有channel表达式都会被求值
      • 所有被发送的表达式都会被求值
      • 如果任意某个通信可以进行，它就执行；其他被忽略。
      • 如果有多个case都可以运行，Select会随机地选出一个执行。其他不会执行。
      • 否则：如果有default子句，则执行该语句。
      • 如果没有default字句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. //select用于退出
    6. func fibonacci(c, quit chan int) {
    7.     x, y := 0, 1
    8.     for {
    9.         select {
    10.         case c <- x:
    11.             x, y = y, x+y
    12.         case <-quit:
    13.             fmt.Println("quit")
    14.             return
    15.         }
    16.     } 
    17. }
    18.  
    19. func main() {
    20.     c := make(chan int)
    21.     quit := make(chan int)
    22.     go func() {
    23.         for i := 0; i < 10; i++ {
    24.             fmt.Println(<-c)
    25.         }
    26.         quit <- 0
    27.     }()
    28.     fibonacci(c, quit)
    29. }
    timeout demo
    1. package main
    2.  
    3. import "time"
    4. import "fmt"
    5.  
    6. func main() {
    7.     c1 := make(chan string, 1)
    8.     go func() {
    9.         time.Sleep(time.Second * 2)
    10.         c1 <- "result 1"
    11.     }()
    12.     select {
    13.     case res := <-c1:
    14.         fmt.Println(res)
    15.     //超时退出
    16.     case <-time.After(time.Second * 1):
    17.         fmt.Println("timeout 1")
    18.     }
    19. }
    单向通道 demo

    send chan <- string//只能发送给send

    read <-chan string// 只能读取read

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "time"
    6. )
    7.  
    8. func Produce(out chan<- int) {
    9.     for i := 0; i < 10; i++ {
    10.         out <- i * i
    11.     }
    12.  
    13. }
    14.  
    15. func Consumer(in <-chan int) {
    16.     for num := range in {
    17.         fmt.Println(num)
    18.     }
    19. }
    20.  
    21. func main() {
    22.     c := make(chan int, 0)
    23.  
    24.     go Produce(c)
    25.     go Consumer(c)
    26.  
    27.     time.Sleep(time.Second)
    28. }

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 只能发送给管道
    6. func Counter(out chan<- int) {
    7.     for i := 0; i < 10; i++ {
    8.         out <- i
    9.     }
    10.     close(out)
    11. }
    12.  
    13. // chan <-  只能发送给管道     <-chan 管道发送嘛，因此只能接收
    14. func Squarer(out chan<- int, in <-chan int) {
    15.     for i := range in {
    16.         out <- i * i
    17.     }
    18.     close(out)
    19. }
    20.  
    21. func Printer(in <-chan int) {
    22.     for i := range in {
    23.         fmt.Println(i)
    24.     }
    25. }
    26.  
    27. func main() {
    28.     ch1 := make(chan int)
    29.     ch2 := make(chan int)
    30.     go Counter(ch1)
    31.     go Squarer(ch2, ch1)
    32.     Printer(ch2)
    33. }

    输出0-9的平方。

    协程池demo

    Golang学习篇——协程池_golang 携程池-CSDN博客

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "math/rand"
    6.     "sync"
    7. )
    8.  
    9. // 当前task
    10. type Task struct {
    11.     Id     int
    12.     Random int
    13. }
    14.  
    15. // 结果
    16. type Result struct {
    17.     Task *Task
    18.     Sum  int
    19. }
    20.  
    21. // 创建Task
    22. func CreateTask(taskChan chan<- *Task, wg *sync.WaitGroup) {
    23.     defer wg.Done()
    24.     for id := 0; id < 100000; id++ {
    25.         //创建Task
    26.         task := &Task{
    27.             Id:     id,
    28.             Random: rand.Intn(200) + 1,
    29.         }
    30.         // 传递给taskChan管道
    31.         taskChan <- task
    32.     }
    33.     close(taskChan)
    34.  
    35. }
    36.  
    37. // 创建线程池来处理
    38. func CreatePool(num int, taskChan <-chan *Task, resultChan chan<- *Result, wg *sync.WaitGroup) {
    39.     for i := 0; i < num; i++ {
    40.         wg.Add(1)
    41.         // 创建多个goroutine并发
    42.         go func() {
    43.             for task := range taskChan {
    44.                 // 当前的Num
    45.                 currentNum := task.Random
    46.                 sum := 0
    47.                 // 计算sum的值
    48.                 for currentNum != 0 {
    49.                     temp := currentNum % 10
    50.                     sum += temp
    51.                     currentNum /= 10
    52.                 }
    53.                 // 此时任务的结果是：
    54.                 currentResult := &Result{
    55.                     Task: task,
    56.                     Sum:  sum,
    57.                 }
    58.                 // 发送给结果管道
    59.                 resultChan <- currentResult
    60.             }
    61.             wg.Done()
    62.         }()
    63.     }
    64.  
    65. }
    66.  
    67. // 开启打印 Result
    68. func PrintResult(resultChan <-chan *Result) {
    69.     //输出
    70.     for res := range resultChan {
    71.         fmt.Printf("输出结果，Id:=%d，Random:=%d，Sum:=%d\n", res.Task.Id, res.Task.Random, res.Sum)
    72.     }
    73. }
    74.  
    75. func main() {
    76.     // 创建task管道，传递task
    77.     taskChan := make(chan *Task, 128)
    78.  
    79.     // 结果管道
    80.     resultChan := make(chan *Result, 128)
    81.  
    82.     // 确保goroutine全部完成
    83.     var wg sync.WaitGroup
    84.  
    85.     wg.Add(1)
    86.     go CreateTask(taskChan, &wg)
    87.  
    88.     // 创建协程池
    89.     CreatePool(133, taskChan, resultChan, &wg)
    90.  
    91.     go func() {
    92.         wg.Wait()
    93.         close(resultChan)
    94.     }()
    95.  
    96.     // 创建协程进行打印
    97.     PrintResult(resultChan)
    98.  
    99. }

    channel一定注意防止被阻塞而导致程序出现死锁！！！

    并发安全和锁

    互斥锁是一种常用的控制共享资源访问的方法，它能够保证同时只有一个goroutine可以访问共享资源。sync.Mutex

    sync.Mutex互斥锁demo

    多个goroutine对同一个共享资源（当前的x）的竞争你，x=x+1，在汇编当中并不是原子性的操作，因此并发时会导致数据不一致，方法1，上锁。

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "sync/atomic"
    7. )
    8.  
    9. var (
    10.     total int32
    11.     wg    sync.WaitGroup
    12.     mutex sync.Mutex
    13. )
    14.  
    15. func Add() {
    16.     defer wg.Done()
    17.  
    18.     for i := 0; i < 10000; i++ {
    19.         //原子操作
    20.         atomic.AddInt32(&total, 1)
    21.         //mutex.Lock()
    22.         //total++
    23.         //mutex.Unlock()
    24.     }
    25.  
    26. }
    27.  
    28. func Del() {
    29.     defer wg.Done()
    30.  
    31.     for i := 0; i < 10000; i++ {
    32.         atomic.AddInt32(&total, -1)
    33.         //mutex.Lock()
    34.         //total--
    35.         //mutex.Unlock()
    36.     }
    37.  
    38. }
    39.  
    40. func main() {
    41.  
    42.     fmt.Println("origin num:", total)
    43.  
    44.     wg.Add(2)
    45.  
    46.     go Add()
    47.     go Del()
    48.  
    49.     wg.Wait()
    50.     fmt.Println("After num:", total)
    51. }
    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6. )
    7.  
    8. var x int64
    9. var wg sync.WaitGroup
    10. var lock sync.Mutex
    11.  
    12. func Add() {
    13.     for i := 0; i < 50; i++ {
    14.         lock.Lock()
    15.         x = x + 1
    16.         lock.Unlock()
    17.     }
    18.     wg.Done()
    19. }
    20.  
    21. func main() {
    22.     wg.Add(2)
    23.     go Add()
    24.     go Add()
    25.     wg.Wait()
    26.     fmt.Println(x)
    27. }

    读写互斥锁 demo
    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    8.  
    9. var (
    10.     x      int64
    11.     wg     sync.WaitGroup
    12.     lock   sync.Mutex
    13.     rwlock sync.RWMutex //读写互斥锁
    14. )
    15.  
    16. func Write() {
    17.     //lock.Lock() //加互斥锁
    18.     rwlock.Lock()
    19.     x = x + 1
    20.     time.Sleep(10 * time.Millisecond)
    21.     rwlock.Unlock()
    22.     //lock.Unlock() //解互斥锁
    23.     wg.Done()
    24. }
    25.  
    26. func Read() {
    27.     //lock.Lock()
    28.     rwlock.RLock()
    29.     time.Sleep(time.Millisecond)
    30.  
    31.     rwlock.RUnlock()
    32.     //lock.Unlock()
    33.     wg.Done()
    34. }
    35.  
    36. func main() {
    37.     start := time.Now()
    38.  
    39.     for i := 0; i < 10; i++ {
    40.         wg.Add(1)
    41.         go Write()
    42.     }
    43.  
    44.     for i := 0; i < 1000; i++ {
    45.         wg.Add(1)
    46.         go Read()
    47.     }
    48.  
    49.     wg.Wait()
    50.     end := time.Now()
    51.     fmt.Println(end.Sub(start))
    52. }

    sync

    前面介绍过sync的一些方法

    sync.WaitGroup

    sync.Once

    参考：Go sync.Once | Go 语言高性能编程 | 极客兔兔

    执行一次的函数，可以在代码任意位置加载，常用于单例模式(懒汉式),并发场景安全。而init是package首次执行时加载(饿汉式)

    对外接口：func (o *Once) Do(f func())

    sync.Map

    这个是并发安全的Map

    原子操作

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "sync/atomic"
    7.     "time"
    8. )
    9.  
    10. var x int64
    11. var l sync.Mutex
    12. var wg sync.WaitGroup
    13.  
    14. // 普通版加函数
    15. func add() {
    16.     // x = x + 1
    17.     x++ // 等价于上面的操作
    18.     wg.Done()
    19. }
    20.  
    21. // 互斥锁版加函数
    22. func mutexAdd() {
    23.     l.Lock()
    24.     x++
    25.     l.Unlock()
    26.     wg.Done()
    27. }
    28.  
    29. // 原子操作版加函数
    30. func atomicAdd() {
    31.     atomic.AddInt64(&x, 1)
    32.     wg.Done()
    33. }
    34.  
    35. func main() {
    36.     start := time.Now()
    37.     for i := 0; i < 10000; i++ {
    38.         wg.Add(1)
    39.         //go add() // 普通版add函数 不是并发安全的
    40.         //go mutexAdd() // 加锁版add函数 是并发安全的，但是加锁性能开销大
    41.         go atomicAdd() // 原子操作版add函数 是并发安全，性能优于加锁版
    42.     }
    43.     wg.Wait()
    44.     end := time.Now()
    45.     fmt.Println(x)
    46.     fmt.Println(end.Sub(start))
    47. }

    Context

    context详解：https://www.cnblogs.com/juanmaofeifei/p/14439957.html

    Go 语言并发编程与 Context | Go 语言设计与实现

    Context是用来用来处理goroutine，可以在多个goroutine中传递取消信号、超时等。

    通俗的解释：Context · Go语言中文文档

    由于golang的server在goroutine当中，context就是有效管理这些goroutine，相互调用的goroutine之间通过传递context变量保持关联，这样在不用暴露各goroutine内部实现细节的前提下，有效地控制各goroutine的运行。

    引入--退出goroutine
    方式1，采用全局变量
    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    8.  
    9. var wg sync.WaitGroup
    10.  
    11. // 退出全局变量
    12. var stop bool
    13.  
    14. func worker() {
    15.     defer wg.Done()
    16.     for {
    17.         if stop {
    18.             break
    19.         }
    20.         time.Sleep(time.Second)
    21.         fmt.Println("worker")
    22.     }
    23. }
    24.  
    25. func main() {
    26.     wg.Add(1)
    27.     go worker()
    28.  
    29.     time.Sleep(3 * time.Second)
    30.     stop = true
    31.     wg.Wait()
    32. }
    方式2，采用管道通信
    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    8.  
    9. var wg sync.WaitGroup
    10.  
    11. var ch = make(chan struct{})
    12.  
    13. func worker() {
    14.     defer wg.Done()
    15. LOOP:
    16.     for {
    17.  
    18.         select {
    19.         case <-ch:
    20.             fmt.Println("exit")
    21.             break LOOP
    22.         default:
    23.             time.Sleep(time.Second)
    24.             fmt.Println("worker")
    25.         }
    26.  
    27.     }
    28. }
    29.  
    30. func main() {
    31.     wg.Add(1)
    32.     go worker()
    33.  
    34.     time.Sleep(3 * time.Second)
    35.     ch <- struct{}{}
    36.     wg.Wait()
    37. }
    方式3，采用context
    1. package main
    2.  
    3. import (
    4.     "context"
    5.     "fmt"
    6.     "sync"
    7.     "time"
    8. )
    9.  
    10. var wg sync.WaitGroup
    11.  
    12. func worker(ctx context.Context) {
    13.     defer wg.Done()
    14. LOOP:
    15.     for {
    16.  
    17.         select {
    18.         case <-ctx.Done():
    19.             fmt.Println("exit")
    20.             break LOOP
    21.         default:
    22.             time.Sleep(time.Second)
    23.             fmt.Println("worker")
    24.         }
    25.  
    26.     }
    27. }
    28.  
    29. func main() {
    30.     wg.Add(1)
    31.     ctx, cancel := context.WithCancel(context.Background())
    32.     go worker(ctx)
    33.  
    34.     time.Sleep(3 * time.Second)
    35.     cancel() //等待子routine结束
    36.  
    37.     wg.Wait()
    38. }

    如果函数当中需要被控制、超时、传递时，但不希望改变原来的接口时，函数第一个参数传入ctx。

    context

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

    WithDeadline
    1. package main
    2.  
    3. import (
    4.     "context"
    5.     "fmt"
    6.     "time"
    7. )
    8.  
    9. func main() {
    10.     d := time.Now().Add(50 * time.Millisecond)
    11.     ctx, canel := context.WithDeadline(context.Background(), d)
    12.  
    13.     // 尽管ctx会过期，但在任何情况下调用它的cancel函数都是很好的实践。
    14.     // 如果不这样做，可能会使上下文及其父类存活的时间超过必要的时间。
    15.     defer canel()
    16.  
    17.     select {
    18.     case <-time.After(10 * time.Millisecond):
    19.         fmt.Println("overslept")
    20.     case <-ctx.Done():
    21.         fmt.Println(ctx.Err())
    22.     }
    23. }

    WithTimeout
    1. package main
    2.  
    3. import (
    4.     "context"
    5.     "fmt"
    6.     "sync"
    7.     "time"
    8. )
    9.  
    10. var wg sync.WaitGroup
    11.  
    12. func worker(ctx context.Context) {
    13.     defer wg.Done()
    14. LOOP:
    15.     for {
    16.  
    17.         select {
    18.         case <-ctx.Done():
    19.             fmt.Println("exit")
    20.             break LOOP
    21.         default:
    22.             time.Sleep(time.Second)
    23.             fmt.Println("worker")
    24.         }
    25.  
    26.     }
    27. }
    28.  
    29. func main() {
    30.     wg.Add(1)
    31.  
    32.     //超时控制
    33.     ctx, _ := context.WithTimeout(context.Background(), 6*time.Second)
    34.     go worker(ctx)
    35.  
    36.     time.Sleep(3 * time.Second)
    37.     wg.Wait()
    38. }
    WithValue
    1. package main
    2.  
    3. import (
    4.     "context"
    5.     "fmt"
    6.     "sync"
    7.     "time"
    8. )
    9.  
    10. var wg sync.WaitGroup
    11.  
    12. func worker(ctx context.Context) {
    13.     //拿到key，value
    14.     fmt.Printf("traceid:%s\n", ctx.Value("traceid"))
    15.     //记录一些日志等等，方便排查
    16.  
    17.     defer wg.Done()
    18. LOOP:
    19.     for {
    20.  
    21.         select {
    22.         case <-ctx.Done():
    23.             fmt.Println("exit")
    24.             break LOOP
    25.         default:
    26.             time.Sleep(time.Second)
    27.             fmt.Println("worker")
    28.         }
    29.  
    30.     }
    31. }
    32.  
    33. func main() {
    34.     wg.Add(1)
    35.  
    36.     //超时控制
    37.     ctx, _ := context.WithTimeout(context.Background(), 6*time.Second)
    38.  
    39.     //传递一些值，后续可能链路追踪id
    40.     childCtx := context.WithValue(ctx, "traceid", "123456")
    41.  
    42.     go worker(childCtx)
    43.  
    44.     time.Sleep(3 * time.Second)
    45.     wg.Wait()
    46. }
  • 相关阅读:
    vue3 解决警告: Promise returned from xxx is ignored 和 $router未定义
    JavaFX Scene Builder 3D 控件详解
    o(1)复杂度找出栈中最小的元素
    容器类之QT
    PostgreSQL 15新版本特性解读（含直播问答、PPT资料汇总）
    JavaScriput中数组去重方法之indexof()
    TAMRA-NHS 荧光素-活性酯
    基于ASP.NET的驾校管理系统设计与实现
    智慧农业数字孪生应用案例，数字化农业建设发展现状
    简单的几个递归小算法
  • 原文地址：https://blog.csdn.net/m0_61973596/article/details/138185065