Golang的context包如何在goroutine间传递取消信号和截止时间

Golang的context包用于在goroutine间传递取消信号、截止时间和请求数据，核心是通过context.Context接口及WithCancel、WithDeadline、WithValue等函数实现上下文控制。

Golang的context包主要用于在goroutine之间传递取消信号、截止时间以及请求相关的值。它允许你控制goroutine的生命周期，确保资源得到有效管理，尤其是在处理并发请求时。

解决方案

Context的核心在于其接口和几个关键的实现：

context.Context

context.Background()

context.TODO()

context.WithCancel()

context.WithDeadline()

context.WithValue()

• 传递取消信号： 使用

  context.WithCancel()

  登录后复制
  创建一个带有取消功能的上下文。这个函数返回一个新的上下文和一个取消函数。当调用取消函数时，所有基于该上下文创建的子上下文都会收到取消信号。

  立即学习“go语言免费学习笔记（深入）”；

  package main
  
  import (
      "context"
      "fmt"
      "time"
  )
  
  func worker(ctx context.Context) {
      for {
          select {
          case <-ctx.Done():
              fmt.Println("Worker: 任务取消")
              return
          default:
              fmt.Println("Worker: 执行任务...")
              time.Sleep(time.Second)
          }
      }
  }
  
  func main() {
      ctx, cancel := context.WithCancel(context.Background())
  
      go worker(ctx)
  
      time.Sleep(3 * time.Second)
      fmt.Println("Main: 取消任务")
      cancel()
  
      time.Sleep(time.Second) // 等待worker退出
      fmt.Println("Main: 结束")
  }

  登录后复制

  在这个例子中，

  context.WithCancel

  登录后复制
  创建了一个可取消的上下文。

  worker

  登录后复制
  函数通过

  ctx.Done()

  登录后复制
  监听取消信号。主函数在 3 秒后调用

  cancel()

  登录后复制
  ，导致

  worker

  登录后复制
  退出。

• 传递截止时间： 使用

  context.WithDeadline()

  登录后复制
  或

  context.WithTimeout()

  登录后复制
  创建一个带有截止时间的上下文。当到达截止时间时，上下文会自动取消。

  package main
  
  import (
      "context"
      "fmt"
      "time"
  )
  
  func worker(ctx context.Context) {
      deadline, ok := ctx.Deadline()
      if ok {
          fmt.Printf("Worker: 截止时间 %v\n", deadline)
      }
  
      for {
          select {
          case <-ctx.Done():
              fmt.Println("Worker: 任务超时或取消")
              return
          default:
              fmt.Println("Worker: 执行任务...")
              time.Sleep(time.Second)
          }
      }
  }
  
  func main() {
      ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
      defer cancel() // 确保在main函数退出时取消context，释放资源
  
      go worker(ctx)
  
      time.Sleep(3 * time.Second)
      fmt.Println("Main: 结束")
  }

  登录后复制

  这里，

  context.WithTimeout

  登录后复制
  创建了一个 2 秒后自动取消的上下文。即使主函数没有显式调用

  cancel()

  登录后复制
  ，

  worker

  登录后复制
  也会在 2 秒后退出。

  defer cancel()

  登录后复制
  是一个良好的实践，确保上下文在不再需要时被取消，避免资源泄漏。

• 传递值： 虽然主要用于取消和截止时间，

  context.WithValue()

  登录后复制
  也可以用于传递请求特定的值。但应谨慎使用，避免滥用上下文传递大量数据。

  package main
  
  import (
      "context"
      "fmt"
  )
  
  func worker(ctx context.Context) {
      userID := ctx.Value("userID")
      if userID != nil {
          fmt.Printf("Worker: userID = %v\n", userID)
      } else {
          fmt.Println("Worker: userID 未找到")
      }
  }
  
  func main() {
      ctx := context.WithValue(context.Background(), "userID", "12345")
  
      go worker(ctx)
  
      fmt.Println("Main: 结束")
  }

  登录后复制

  在这个例子中，

  context.WithValue

  登录后复制
  将 "userID" 的值传递给

  worker

  登录后复制
  函数。注意，键的类型应该是自定义类型，避免与其他包的键冲突。

如何避免Context泄露？

Context泄露指的是Context被传递给goroutine，但goroutine并没有在适当的时候退出，导致资源无法释放。这通常发生在goroutine持续运行，即使其结果不再需要，或者Context的父Context已经取消。

1. 使用defer取消Context： 当使用

   context.WithTimeout

   登录后复制
   或

   context.WithDeadline

   登录后复制
   创建Context时，始终使用

   defer cancel()

   登录后复制
   来确保Context在不再需要时被取消。

   func main() {
       ctx, cancel := context.WithTimeout(context.Background(), time.Second)
       defer cancel()
       // ...
   }

   登录后复制

2. 确保goroutine监听Done()通道： 所有接收Context的goroutine都应该监听

   ctx.Done()

   登录后复制
   通道，并在收到信号时退出。

   func worker(ctx context.Context) {
       for {
           select {
           case <-ctx.Done():
               // 清理资源并退出
               return
           default:
               // 执行任务
           }
       }
   }

   登录后复制

3. 避免无限期阻塞的goroutine： 确保goroutine不会因为某些操作（如等待channel）而无限期阻塞。可以使用

   select

   登录后复制
   语句和

   ctx.Done()

   登录后复制
   来设置超时。
   

   美间AI

   美间AI：让设计更简单

   45

   查看详情

   func worker(ctx context.Context, ch <-chan int) {
       for {
           select {
           case <-ctx.Done():
               return
           case val := <-ch:
               // 处理val
           case <-time.After(time.Second):
               // 超时处理
           }
       }
   }

   登录后复制

4. 避免在循环中创建Context： 如果需要在循环中创建Context，确保每次循环都创建一个新的Context，而不是重复使用同一个Context。

   for i := 0; i < 10; i++ {
       ctx, cancel := context.WithTimeout(context.Background(), time.Second)
       go func(ctx context.Context, i int) {
           defer cancel()
           // ...
       }(ctx, i)
   }

   登录后复制

5. 使用Context传递必要信息： 避免使用Context传递大量数据。Context主要用于传递取消信号、截止时间和少量请求相关的值。对于大量数据，应使用函数参数或其他更合适的方式传递。

Context的Value应该放什么？

context.Value

context.Value

• 适合放置的内容：

  • 请求ID (Request ID): 用于追踪跨多个服务的请求。
  • 认证信息 (Authentication Token): 例如用户ID或API密钥，用于身份验证和授权。
  • 截止时间 (Deadline): 虽然可以使用

    context.WithDeadline

    登录后复制
    ，但在某些场景下，将截止时间作为值传递可能更灵活。
  • 追踪信息 (Tracing Information): 用于分布式追踪系统，例如Jaeger或Zipkin。

• 不适合放置的内容：

  • 大量数据： Context不适合传递大量数据，因为这会增加Context的开销，并可能导致性能问题。应该使用函数参数或其他数据结构来传递大量数据。
  • 可选参数： 可选参数应该使用函数参数或选项模式来传递，而不是Context。
  • 控制流： Context主要用于取消和截止时间，不应该用于控制程序的执行流程。
  • 依赖注入： Context不应该用作依赖注入的机制。应该使用专门的依赖注入库。

如何测试使用了Context的代码？

测试使用Context的代码需要模拟Context的行为，例如取消信号和截止时间。

1. 使用

   context.Background()

   登录后复制
   或

   context.TODO()

   登录后复制
   作为基础Context： 在测试中，可以使用

   context.Background()

   登录后复制
   或

   context.TODO()

   登录后复制
   作为基础Context，然后使用

   context.WithCancel

   登录后复制
   、

   context.WithTimeout

   登录后复制
   或

   context.WithValue

   登录后复制
   来创建具有特定行为的Context。

   func TestWorker(t *testing.T) {
       ctx := context.Background()
       // ...
   }

   登录后复制

2. 模拟取消信号： 可以使用

   context.WithCancel

   登录后复制
   创建一个可取消的Context，并在测试中调用取消函数来模拟取消信号。

   func TestWorkerCancel(t *testing.T) {
       ctx, cancel := context.WithCancel(context.Background())
       defer cancel()
   
       go worker(ctx)
   
       // 模拟取消信号
       cancel()
   
       // 等待goroutine退出
       time.Sleep(time.Millisecond * 100)
   
       // 验证结果
       // ...
   }

   登录后复制

3. 模拟截止时间： 可以使用

   context.WithTimeout

   登录后复制
   创建一个带有截止时间的Context，并等待超时来模拟截止时间。

   func TestWorkerTimeout(t *testing.T) {
       ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*100)
       defer cancel()
   
       go worker(ctx)
   
       // 等待超时
       time.Sleep(time.Millisecond * 200)
   
       // 验证结果
       // ...
   }

   登录后复制

4. 验证Context传递的值： 可以使用

   ctx.Value()

   登录后复制
   来验证Context中传递的值是否正确。

   func TestWorkerValue(t *testing.T) {
       ctx := context.WithValue(context.Background(), "userID", "123")
   
       go worker(ctx)
   
       // 等待goroutine执行
       time.Sleep(time.Millisecond * 100)
   
       // 验证结果
       // ...
   }

   登录后复制

5. 使用

   testing.T

   登录后复制
   的

   Cleanup

   登录后复制
   函数： 可以使用

   testing.T

   登录后复制
   的

   Cleanup

   登录后复制
   函数来确保在测试结束后取消Context，释放资源。

   func TestWorker(t *testing.T) {
       ctx, cancel := context.WithCancel(context.Background())
       t.Cleanup(cancel)
   
       go worker(ctx)
   
       // ...
   }

   登录后复制

通过这些方法，可以有效地测试使用了Context的代码，确保其在各种情况下都能正确运行。

以上就是Golang的context包如何在goroutine间传递取消信号和截止时间的详细内容，更多请关注php中文网其它相关文章！