Go并发编程（三）context&waitgroup

落日映苍穹つ 2023-01-18 06:51 147阅读 0赞

### 文章目录 ###

*  Go并发编程（三）context&waitgroup
 *   *  使用Context
     *  WaitGroup
     *  Context
     *   *  使用场景
         *   *  请求链路传值
             *  主动和超时取消请求

# Go并发编程（三）context&waitgroup #

> 控制并发的方式有两种：

*  使用WaitGroup
    
     *  通过WaitGroup等待所有goroutine执行完在执行别的事
 *  ## 使用Context ##

## WaitGroup ##

waitGroup会等待所有的goroutine执行完后在执行其他的事

import (
    	"fmt"
    	"sync"
    	"time"
    )
    
    func TestWaitGroup()  {
        
    	wg := new(sync.WaitGroup)
    	wg.Add(2)
    	go func1(wg)
    	go func2(wg)
    	wg.Wait()
    	fmt.Println("all finish")
    }
    
    func func1(wg *sync.WaitGroup)  {
        
    	fmt.Println("func1 start")
    	time.Sleep(3 * time.Second)
    	fmt.Println("func1 finish")
    	wg.Done()
    }
    
    func func2(wg *sync.WaitGroup)  {
        
    	fmt.Println("func2 start")
    	time.Sleep(2 * time.Second)
    	fmt.Println("func2 finish")
    	wg.Done()
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkyMjI4OQ_size_16_color_FFFFFF_t_70]

context是一个线程安全的请求上下文，携带了请求的全局数据，如超时时间，截止时间，信号量，k-v数据等

## Context ##

Context是一个接口，接口定义如下：

type Context interface {
        
    	Deadline() (deadline time.Time, ok bool)	//  返回 context.Context 被取消的时间，也就是完成工作的截止日期；
    	Done() <-chan struct{
        }	// 返回一个 Channel，这个 Channel 会在当前工作完成或者上下文被取消后关闭
    	Err() error	// 返回 context.Context 结束的原因
    		//如果 context.Context 被取消，会返回 Canceled 错误；
    		//如果 context.Context 超时，会返回 DeadlineExceeded 错误；
    	Value(key interface{
        }) interface{
        }	// 从 context.Context 中获取键对应的值，对于同一个上下文来说，多次调用 Value 并传入相同的 Key 会返回相同的结果，该方法可以用来传递请求特定的数据；
    }

### 使用场景 ###

#### 请求链路传值 ####

go服务中每一个请求都是单独的goroutine处理的，对于一个请求我们会创建多个goroutine去处理，有的goroutine去做数据库操作，有的goroutine去做rpc请求，context包的作用就是在多个goroutine之间同步请求的特定数据。

![ee084778f956d8202c94c881926806bb.png][]

每个context.Context都是在最顶层的goroutine中传递给下一层，当上层的goroutine发生错误时，可以将信号传递到下层的goroutine，及时退出该请求的所有goroutine，以减少资源的开销。

import (
    	"context"
    	"fmt"
    )
    
    func TestMyContext()  {
        
    	ctx := context.Background()
    	func1(ctx)
    }
    
    func func1(ctx context.Context)  {
        
    	// 将需要传的值放入context中，自请求链路自上而下往下传，键值对绑定
    	ctx = context.WithValue(ctx,"k1","v1")
    	func2(ctx)
    }
    
    func func2(ctx context.Context)  {
        
    	fmt.Println(ctx.Value("k1").(string))
    }

#### 主动和超时取消请求 ####

请求中的所有goroutine监听ctx.Done()返回的管道中的信号，一旦监听到信号消费成功，所有goroutine立即退出返回。

// 超时或者手动触发cancel都会发消息到Done管道·
    context.WithTimeout(context.Background(),time.Second * 3) // 超时时间：3s
    
    // 主动取消需要手动执行cancel，cancel执行后，取消信号进入Done管道，请求取消，主动通知机制
    ctx,cancel := context.WithCancel(context.Background())

超时取消请求：

// 场景二：超时取消请求
    func TestContext2(){
        
    	ctx,cancel := context.WithTimeout(context.Background(),time.Second * 3) // 超时时间：3s
    	defer cancel()
    	func11(ctx)
    	time.Sleep(2 * time.Second)
    }
    
    func func11(ctx context.Context)  {
        
    	resp := make(chan struct{
        }, 1)
    
    	go func() {
        
    		// 处理耗时
    		time.Sleep(time.Second * 10)
    		resp <- struct{
        }{
        }
    	}()
    	select {
        
    		case <- ctx.Done() :	// 多个goroutine Done返回的管道中的消息，一旦消费到信号，立即停止工作
    			fmt.Println("request timeout")
    		case num := <- resp:
    			fmt.Println("正常业务处理：",num)
    	}
    	fmt.Println("finish")
    }

主动取消请求

// 主动取消请求
    func TestContext3()  {
        
    	wg := new(sync.WaitGroup)
    	wg.Add(1)
    	ctx,cancel := context.WithCancel(context.Background())
    	go func111(ctx,wg)
    	time.Sleep(2 * time.Second)	// main goroutine执行2秒后取消，所有goroutine退出
    	cancel()
    	wg.Wait() // 等待goroutine退出
    	fmt.Println("全部goroutine都已退出")
    }
    
    func func111(ctx context.Context, wg *sync.WaitGroup) {
        
    	defer wg.Done()
    	resp := make(chan int)
    	go func() {
        
    		// 模型耗时请求
    		time.Sleep(3 * time.Second)
    		resp <- 10
    	}()
    	select {
        
    	case <- ctx.Done():
    		fmt.Println("request canceled")
    	case num := <- resp:
    		fmt.Println(num)
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTkyMjI4OQ_size_16_color_FFFFFF_t_70]: /images/20221021/fcfd708c7cc249c8b343017d7e24ab60.png
[ee084778f956d8202c94c881926806bb.png]: /images/20221021/e89bb134c0e14c688f438d826352ad84.png