Golangcontext取消与截止时间详解

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《Golang context传递取消与截止时间详解》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

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() 创建一个带有取消功能的上下文。这个函数返回一个新的上下文和一个取消函数。当调用取消函数时，所有基于该上下文创建的子上下文都会收到取消信号。

  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()来设置超时。

   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 主要用于传递与请求相关的元数据，例如用户ID、请求ID、认证令牌等。但是，滥用 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的代码，确保其在各种情况下都能正确运行。

到这里，我们也就讲完了《Golangcontext取消与截止时间详解》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于golang,Goroutine,context,截止时间,取消信号的知识点！