【Go语言学习系列25】context包详解

已于 2025-04-11 00:21:53 修改
阅读量979 收藏 18
点赞数 25
CC 4.0 BY-SA版权
分类专栏： Go语言学习系列 文章标签： golang 学习 开发语言
于 2025-03-24 19:05:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/GopherTribe/article/details/146483596

📚 原创系列： “Go语言学习系列”

🔄 转载说明： 本文最初发布于"Gopher部落"微信公众号，经原作者授权转载。

🔗 关注原创： 欢迎扫描文末二维码，关注"Gopher部落"微信公众号获取第一手Go技术文章。

📑 Go语言学习系列导航

本文是【Go语言学习系列】的第25篇，当前位于第二阶段（基础巩固篇）

🚀 第二阶段：基础巩固篇
  1. 13-包管理深入理解
  2. 14-标准库探索（一）：io与文件操作
  3. 15-标准库探索（二）：字符串处理
  4. 16-标准库探索（三）：时间与日期
  5. 17-标准库探索（四）：JSON处理
  6. 18-标准库探索（五）：HTTP客户端
  7. 19-标准库探索（六）：HTTP服务器
  8. 20-单元测试基础
  9. 21-基准测试与性能剖析入门
  10. 22-反射机制基础
  11. 23-Go中的面向对象编程
  12. 24-函数式编程在Go中的应用
  13. 25-context包详解 👈 当前位置
  14. 26-依赖注入与控制反转
  15. 27-第二阶段项目实战：RESTful API服务

📚 查看完整Go语言学习系列导航

📖 文章导读

在本文中，您将了解：

  • Context包的设计理念与核心接口
  • 如何使用Context控制goroutine的取消
  • 如何设置超时和截止时间控制
  • 如何通过Context在请求范围内传递数据
  • Context在HTTP服务器、数据库操作和gRPC中的应用
  • Context使用的最佳实践与常见陷阱

对于开发高并发、健壮的Go应用程序，有效使用Context是必不可少的技能。无论是编写Web服务、微服务还是任何涉及并发控制的程序，本文都将帮助您掌握Context的正确使用方法。

context包详解：优雅控制Go并发的利器

在Go的并发编程中，经常需要处理一组相关的goroutine，如何优雅地通知这些goroutine退出、传递请求范围的数据或者控制超时？标准库中的context包提供了解决这些问题的优雅方案。本文将深入剖析context包的设计理念和使用方法，帮助你编写更加健壮的Go并发程序。

一、Context的设计理念

1.1 核心目标

Context（上下文）包设计的核心目标是为了在不同goroutine之间传递截止时间、取消信号以及请求范围的值，尤其适用于处理请求的场景（如HTTP请求）。Context主要解决了以下问题：

  1. 取消控制：如何通知多个goroutine取消当前任务
  2. 超时控制：如何为操作设置截止时间或超时时间
  3. 值传递：如何安全地在请求范围内传递数据
  4. 层次化：如何构建可继承的上下文关系

1.2 Context接口设计

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

type Context interface {
    // 返回context的截止时间，如果没有设置截止时间，ok返回false
    Deadline() (deadline time.Time, ok bool)
    
    // 返回一个Channel，当context被取消时，该Channel会被关闭
    Done() <-chan struct{}
    
    // 如果Done()返回的Channel未关闭，返回nil
    // 如果Done()返回的Channel已关闭，返回context取消的原因
    Err() error
    
    // 从context中获取与key关联的值，如果没有则返回nil
    Value(key interface{}) interface{}
}

这个简洁的接口设计体现了Go语言的设计哲学：简单、正交、组合。

1.3 Context树结构

Context实例可以组成一个树状结构，当父Context取消时，所有从其派生的子Context都会被取消：

emptyCtx
    |
    +--- withCancel ------ withCancel
    |                         |
    +--- withDeadline         +--- withValue
            |
            +--- withTimeout
                    |
                    +--- withValue

这种树状结构使得Context非常适合用于处理多层级的请求和任务控制。

二、使用Context取消操作

2.1 创建可取消的Context

使用context.WithCancel可以创建一个可取消的Context：

// 创建一个可取消的context和取消函数
ctx, cancel := context.WithCancel(context.Background())

// 在不再需要时取消context
defer cancel()

// 启动goroutine执行任务
go doSomething(ctx)

在某个时间点调用cancel()函数会发出取消信号，通知所有使用这个Context的goroutine停止工作。

2.2 监听取消信号

在goroutine中，可以通过Context的Done()方法获取一个channel，当Context被取消时，这个channel会被关闭：

func doSomething(ctx context.Context) {
    // 启动一个工作循环
    for {
        select {
        case <-ctx.Done():
            // Context被取消，停止工作
            fmt.Println("Work cancelled:", ctx.Err())
            return
        default:
            // 执行实际工作
            time.Sleep(100 * time.Millisecond)
            fmt.Println("Working...")
        }
    }
}

2.3 取消传播机制

当一个父Context被取消时，从它派生的所有子Context也会被取消。这种传播机制非常适合处理复杂的请求场景：

func main() {
    // 创建根Context
    rootCtx, rootCancel := context.WithCancel(context.Background())
    defer rootCancel()
    
    // 创建子Context
    childCtx, childCancel := context.WithCancel(rootCtx)
    defer childCancel()
    
    // 启动工作goroutine
    go doSomething(childCtx)
    
    // 5秒后取消根Context
    time.Sleep(5 * time.Second)
    fmt.Println("Cancelling root context...")
    rootCancel()
    
    // 等待观察结果
    time.Sleep(1 * time.Second)
}

当rootCancel()被调用时，childCtx也会被取消，即使childCancel()没有被调用。

2.4 完整示例：并发下载器

下面是一个使用Context控制多个并发下载任务的示例：

func downloadFiles(ctx context.Context, urls []string) error {
    // 创建一个错误通道，用于收集下载过程中的错误
    errCh := make(chan error, len(urls))
    
    // 创建一个WaitGroup，用于等待所有下载任务完成
    var wg sync.WaitGroup
    
    // 为每个URL启动一个下载goroutine
    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()
            
            // 检查Context是否已取消
            select {
            case <-ctx.Done():
                errCh <- fmt.Errorf("download of %s canceled: %v", url, ctx.Err())
                return
            default:
                // 继续下载
            }
            
            // 模拟下载操作
            err := downloadFile(ctx, url)
            if err != nil {
                errCh <- err
            }
        }(url)
    }
    
    // 创建一个goroutine等待所有下载完成并关闭错误通道
    go func() {
        wg.Wait()
        close(errCh)
    }()
    
    // 收集第一个错误
    for err := range errCh {
        return err // 返回第一个遇到的错误
    }
    
    return nil
}

func downloadFile(ctx context.Context, url string) error {
    // 创建HTTP请求
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return err
    }
    
    // 执行请求
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    
    // 处理响应...
    return nil
}

这个示例展示了如何使用Context控制多个下载任务，当任一下载失败或Context被取消时，所有下载都会停止。

三、超时控制

3.1 截止时间控制

使用context.WithDeadline可以创建一个具有截止时间的Context：

// 创建一个10秒后到期的Context
deadline := time.Now().Add(10 * time.Second)
ctx, cancel := context.WithDeadline(context.Background(), deadline)

// 确保在函数退出时取消Context以释放资源
defer cancel()

// 使用具有截止时间的Context
go doSomethingWithDeadline(ctx)

当到达截止时间时，Context会自动取消。

3.2 超时控制

context.WithTimeout是WithDeadline的便捷包装，用于设置相对超时时间：

// 创建一个5秒后超时的Context
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// 使用具有超时的Context
go doSomethingWithTimeout(ctx)

3.3 使用超时控制HTTP请求

在HTTP客户端请求中使用超时控制是一个常见场景：

func fetchURL(url string) ([]byte, error) {
    // 创建一个30秒超时的Context
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    
    // 创建一个带有Context的请求
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return nil, err
    }
    
    // 执行请求
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    // 读取响应体
    return io.ReadAll(resp.Body)
}

3.4 优雅处理超时

当Context超时时，可以通过Err()方法区分不同的错误类型：

func processWithTimeout(ctx context.Context) error {
    select {
    case <-ctx.Done():
        err := ctx.Err()
        if err == context.DeadlineExceeded {
            return fmt.Errorf("operation timed out: %v", err)
        }
        if err == context.Canceled {
            return fmt.Errorf("operation canceled: %v", err)
        }
        return err
    case result := <-doWork():
        return processResult(result)
    }
}

四、使用Context传递值

4.1 创建带值的Context

使用context.WithValue可以创建一个包含键值对的Context：

// 创建一个包含请求ID的Context
ctx := context.WithValue(context.Background(), "request_id", "12345")

// 使用包含值的Context
go processRequest(ctx)

4.2 获取Context中的值

在goroutine中，可以通过Context的Value()方法获取传递的值：

func processRequest(ctx context.Context) {
    // 获取请求ID
    requestID, ok := ctx.Value("request_id").(string)
    if !ok {
        requestID = "unknown"
    }
    
    fmt.Printf("Processing request %s\n", requestID)
    // 处理请求...
}

4.3 使用自定义类型避免键冲突

为了避免不同包之间的键名冲突，建议使用自定义类型作为Context的键：

// 定义一个私有的类型作为键
type contextKey string

// 定义常量作为具体的键
const (
    requestIDKey contextKey = "request_id"
    userIDKey    contextKey = "user_id"
)

// 使用自定义类型作为键创建Context
ctx := context.WithValue(context.Background(), requestIDKey, "12345")
ctx = context.WithValue(ctx, userIDKey, "user-567")

// 获取值时使用相同的键类型
func getRequestID(ctx context.Context) string {
    requestID, ok := ctx.Value(requestIDKey).(string)
    if !ok {
        return "unknown"
    }
    return requestID
}

4.4 值传递的最佳实践

Context中的值传递主要用于传递请求范围的数据，如请求ID、认证令牌等。不应该将它用于传递可选参数或功能控制。一些最佳实践包括：

  1. 只存储请求范围内的数据，不要存储全局状态
  2. 值应该是不可变的，避免并发修改
  3. 对于简单类型，使用强类型键避免类型断言错误
  4. 不要滥用Context存储大量数据，这会降低代码可读性和可维护性

五、Context在实际应用中的集成

5.1 与HTTP服务器集成

Go的HTTP服务器默认为每个请求提供了一个Context：

func handleRequest(w http.ResponseWriter, r *http.Request) {
    // 获取请求的Context
    ctx := r.Context()
    
    // 当客户端断开连接时，Context会被取消
    go doSlowOperation(ctx)
    
    select {
    case <-ctx.Done():
        // 客户端取消了请求
        log.Println("Request canceled by client")
        return
    case result := <-processRequest(ctx):
        // 处理结果
        fmt.Fprintf(w, "Result: %v", result)
    }
}

5.2 与数据库操作集成

许多数据库驱动支持Context，可以用来控制查询超时：

func queryWithTimeout(ctx context.Context, db *sql.DB, query string) ([]string, error) {
    // 执行带有Context的查询
    rows, err := db.QueryContext(ctx, query)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var results []string
    for rows.Next() {
        var s string
        if err := rows.Scan(&s); err != nil {
            return nil, err
        }
        results = append(results, s)
    }
    
    return results, rows.Err()
}

// 使用超时控制查询
func main() {
    db, err := sql.Open("postgres", "...")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    
    // 创建一个5秒超时的Context
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    results, err := queryWithTimeout(ctx, db, "SELECT * FROM large_table")
    if err != nil {
        if err == context.DeadlineExceeded {
            log.Println("Query timed out")
        } else {
            log.Println("Query error:", err)
        }
        return
    }
    
    // 处理结果...
}

5.3 在gRPC中使用Context

gRPC广泛使用Context进行请求控制：

func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    // 检查Context是否已取消
    select {
    case <-ctx.Done():
        return nil, status.Errorf(codes.Canceled, "request canceled: %v", ctx.Err())
    default:
        // 继续处理
    }
    
    // 执行数据库查询
    user, err := s.db.GetUserByID(ctx, req.UserId)
    if err != nil {
        return nil, status.Errorf(codes.Internal, "failed to get user: %v", err)
    }
    
    return &pb.User{
        Id:   user.ID,
        Name: user.Name,
        Email: user.Email,
    }, nil
}

5.4 实现自定义中间件

Context对于实现HTTP中间件非常有用：

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 生成请求ID
        requestID := uuid.New().String()
        
        // 创建带有请求ID的Context
        ctx := context.WithValue(r.Context(), requestIDKey, requestID)
        
        // 使用新的Context创建请求
        r = r.WithContext(ctx)
        
        // 记录开始时间
        start := time.Now()
        
        // 调用下一个处理器
        next.ServeHTTP(w, r)
        
        // 记录请求完成信息
        log.Printf("Request %s completed in %v", requestID, time.Since(start))
    })
}

六、Context使用的最佳实践与陷阱

6.1 Context传递规范

按照Go的惯例，Context应该是函数的第一个参数：

// 正确的Context参数位置
func DoSomething(ctx context.Context, arg Arg) error {
    // ...
}

// 不推荐的做法
func DoSomething(arg Arg, ctx context.Context) error {
    // ...
}

6.2 避免将Context存储在结构体中

Context应该通过函数参数显式传递，而不是存储在结构体中：

// 不推荐的做法
type Service struct {
    ctx context.Context
    // ...
}

// 推荐的做法
type Service struct {
    // 没有存储Context
}

func (s *Service) DoWork(ctx context.Context) error {
    // 通过参数使用Context
}

6.3 不要传递nil Context

如果不确定使用哪个Context，可以使用context.Background()或context.TODO()：

// 不推荐的做法
func DoSomething(ctx context.Context) {
    if ctx == nil {
        ctx = context.Background()
    }
    // ...
}

// 推荐的做法
func DoSomething(ctx context.Context) {
    // 调用者负责提供有效的Context
    // ...
}

6.4 正确管理取消函数

每次调用WithCancel、WithTimeout或WithDeadline都会返回一个cancel函数，应该在不再需要Context时调用这个函数：

// 推荐的做法
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel() // 确保在函数退出时调用cancel
    
    // 使用ctx...
}

6.5 避免在Context中存储过多数据

Context主要用于传递请求范围的元数据，不应该用于传递大量数据或业务逻辑参数：

// 不推荐的做法
ctx := context.WithValue(ctx, "database", db)
ctx = context.WithValue(ctx, "config", config)
ctx = context.WithValue(ctx, "user_data", hugeUserDataStruct)

// 推荐的做法 - 只存储请求范围的元数据
ctx := context.WithValue(ctx, requestIDKey, requestID)
ctx = context.WithValue(ctx, userIDKey, userID)

七、总结与实践建议

Context包是Go语言中处理并发控制、超时取消和请求范围数据传递的强大工具。通过正确使用Context，可以让你的程序更加健壮，特别是在处理如HTTP请求、数据库操作等场景时。

7.1 核心使用场景

  • 取消操作：当用户取消请求或操作超时时终止goroutine
  • 超时控制：为操作设置绝对或相对的时间限制
  • 请求元数据：传递请求ID、认证信息等跨API边界的数据
  • 信号传播：在goroutine树中传播取消信号

7.2 实践建议

  1. 始终将Context作为第一个参数传递
  2. 不要将Context存储在结构体中
  3. 总是检查Context的Done()通道
  4. 使用自定义类型作为Context的键
  5. 只在Context中存储请求范围的数据
  6. 当创建子goroutine时，传递Context给它们
  7. 使用defer cancel()确保资源释放

通过遵循这些最佳实践，你可以充分利用Context包的强大功能，编写更加健壮和可维护的Go并发程序。

👨‍💻 关于作者与Gopher部落

"Gopher部落"专注于Go语言技术分享，提供从入门到精通的完整学习路线。

🌟 为什么关注我们？

  1. 系统化学习路径：第二阶段15篇文章深入讲解Go核心概念与实践
  2. 实战驱动教学：理论结合实践，每篇文章都有可操作的代码示例
  3. 持续更新内容：定期分享最新Go生态技术动态与大厂实践经验
  4. 专业技术社区：加入我们的技术交流群，与众多Go开发者共同成长

📱 关注方式

  1. 微信公众号：搜索 “Gopher部落” 或 “GopherTribe”
  2. 优快云专栏：点击页面右上角"关注"按钮

💡 读者福利

关注公众号回复 “Context” 即可获取：

  • Context使用最佳实践PDF
  • 高并发控制完整示例代码
  • Go并发模式实战演练

期待与您在Go语言的学习旅程中共同成长！

深度解密Go语言之context
weixin_34132768的博客
06-12 1363
Go 语言的 context 包短小精悍，非常适合新手学习。不论是它的源码还是实际使用，都值得投入时间去学习。 这篇文章依然想尝试全面、深入地去研究。文章相比往期而言，整体不长，希望你看完可以有所收获！ 什么是 context Go 1.7 标准库引入 context，中文译作“上下文”，准确说它是 goroutine 的上下文，包含 goroutine 的运行状态、环境、现场等信息。 conte...
Golang Context详解
2021dragon的博客
06-10 3268
在Go 1.7版本中引入了上下文（context）包，用于在并发编程中管理请求范围的数据、控制生命周期、处理取消信号和超时等。context在Go中具有重要的作用，特别是在并发编程和网络编程中，因此context通常会作为各个函数和方法的首个入参。
理解Go Context机制
weixin_30950887的博客
08-31 334
1 什么是Context 最近在公司分析gRPC源码，proto文件生成的代码，接口函数第一个参数统一是ctx context.Context接口，公司不少同事都不了解这样设计的出发点是什么，其实我也不了解其背后的原理。今天趁着妮妲台风妹子正面登陆深圳，全市停工、停课、停业，在家休息找了一些资料研究把玩一把。 Context通常被译作上下文，它是一个比较抽象的概念。在公司技术讨论时也经常会提到...
Go语言Context机制深度解析：从原理到实践
热门推荐
言之。
04-29 1万+
Context（上下文）是Go语言并发编程的核心机制之一，主要用于在goroutine之间传递取消信号、截止时间和其他请求范围的值。Google在Go 1.7版本中将其引入标准库，现已成为处理并发控制和超时的标准方案。核心优势统一的取消传播机制简洁的API设计与标准库深度集成适用场景网络请求处理微服务调用链资源密集型操作需要超时控制的场景设计哲学显式优于隐式组合优于继承并发安全优先。
Go Context包
寻找09之夏的博客
09-30 662
go context
go context 包
go|Python的个人博客
08-02 804
Context，翻译为"上下文"，context包定义了Context接口类型，其接口方法定义了跨API和进程之间的执行最后期限、取消信号和其他请求范围的值在并发程序中，由于超时、取消操作或者一些异常情况，往往需要进行抢占操作或者中断后续操作,他的底层是通过channel去传递管理信号。例如，父goroutine可以传递一个close信号来关闭此channel，子goroutine通过监听这个channel，那么子goroutine也会退出。......
Go 语言中的 context 包详解
m0_57836225的博客
09-20 1175
context包在 Go 语言中是一个非常强大的工具，它为我们提供了一种有效的方式来处理请求范围的值传递、取消操作和超时控制等问题。在实际的开发中，合理地使用context可以使代码更加简洁、可读、可维护，并且提高应用程序的性能和可靠性。请注意，在使用context时，需要谨慎处理取消函数的调用，避免意外取消操作。同时，也要注意context的生命周期管理，确保在正确的时间创建和取消context。
Go语言中的Context使用详解.doc
最新发布
07-21
Go语言中的Context使用详解.doc
Go语言context包详解与使用规范
"golang context包的理解与应用" 在Golang中，`context`包是用于在请求处理过程中传递上下文信息、取消信号、截止时间和其他请求级数据的关键工具。它帮助确保请求的数据在多层调用中保持一致，并提供了一种优雅的...
Golang之Context详解
高高冷的博客
01-22 1166
golang.org/x/net/context，是golang中的一个标准库，主要作用就是创建一个上下文，实现对程序中创建的协程通过传递上下文信息来实现对协程的管理。
深入理解Golang中的Context包
沈春旭的博客
02-21 9611
context.Context是Go语言中独特的设计，在其他编程语言中我们很少见到类似的概念。context.Context深度支持Golang的高并发。 1. Goroutine和Channel 在理解context包之前，应该首先熟悉Goroutine和Channel，能加深对context的理解。 1.1 Goroutine Goroutine是一个轻量级的执行线程，多个Goroutine比一个线程轻量，所以管理Goroutine消耗的资源相对更少。Goroutine是Go中最基本的执行单元，每一.
Go语言之context包
YouSec995 的博客
04-30 877
channels channels 是一种类型安全的消息队列，充当两个 goroutine 之间的管道，将通过它同步的进行任意资源的交换。chan 控制 goroutines 交互的能力从而创建了 Go 同步机制。当创建的 chan 没有容量时，称为无缓冲通道。反过来，使用容量创建的 chan 称为缓冲通道。 要了解通过 chan 交互的 goroutine 的同步行为是什么，我们需要知道通道的类型和状态。根据我们使用的是无缓冲通道还是缓冲通道，场景会有所不同，所以让我们单独讨论每个场景。 Unbuffer
Go源码--context包
u013915286的博客
06-30 1327
主要讲解context包
Go的context库(包)
weixin_44718747的博客
01-08 393
一、问题的提出： 在 Go http包的Server中，也就是在go的http服务器中，对每一个请求request都会有一个对应的 goroutine 去处理该请求，而且对应的请求处理函数在处理该请求时有可能又会启动新的的 goroutine 用来访问一些后端服务：比如数据库和RPC服务。 而且用来处理同一个请求request的 各goroutine间 通常都需要访问与该request相关的数据，比如终端用户的身份认证信息、验证相关的token、请求的截止时间，那么如何方便的在这些goroutine间（也就
Golang context 包简介
qq_43638113的博客
11-09 405
概述 Golang 的 context Package 提供了一种简洁又强大方式来管理 goroutine 的生命周期，同时提供了一种 Requst-Scope K-V Store。 但是对于新手来说，Context 的概念不算非常的直观，这篇文章来带领大家了解一下 Context 包的基本作用和使用方法。 Context 基本数据结构 Context interface Context int...
Go语言context包的简单介绍
xuan_ting的博客
11-04 543
简介 在 Go http包的Server中，每一个请求在都有一个对应的 goroutine 去处理。请求处理函数通常会启动额外的 goroutine 用来访问后端服务，比如数据库和RPC服务。用来处理一个请求的 goroutine 通常需要访问一些与请求特定的数据，比如终端用户的身份认证信息、验证相关的token、请求的截止时间。 当一个请求被取消或超时时，所有用来处理该请求的 goroutin...
简单理解go语言的context包
地瓜的博客
07-17 415
go context学习笔记 type Context interface { Deadline() (deadline time.Time, ok bool) Done() <-chan struct{} Err() error Value(key interface{}) interface{} } context.Context 是 Go 语言在 1.7 版本中引入标准库的接口，该接口定义了四个需要实现的方法，其中包括： Deadline — 返回 context.Context被
go-Context包详解
Zerore的博客
05-21 598
在go语言中，上下文context.Context用来设置截止日期、同步信号、传递请求相关值得结构体。上下文与Goroutine得关系比较密切，是go语言中独特得设计，在其他编程语言中很少见到类似的概念。 context.Context是一个接口，定义了如下四个方法： // A Context carries a deadline, a cancellation signal, and other values across // API boundaries. // // Context's method
GOLANG context包
seijia的博客
05-27 696
学习golang绕不开并发，本身提供的goroutine搭配上chanel十分好用，但是总是有一些特殊情况，如果要再一定时间内返回结果而goroutine又没有像c的线程一样提供主动结束子进程的方法。 之前自己遇到这种情况的时候也找了一些资料，就用标准库自己写了一个超时，大致是这样的 for i := 0; i < len(data.Data); i++ { select {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Gopher部落

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值