How to use context to implement cross-goroutine communication in Go

Go language, as a programming language that supports concurrency, provides a powerful goroutine mechanism that can execute multiple tasks concurrently during program execution. However, communicating between multiple goroutines is not always easy. In order to solve this problem, the Go language introduced the context package, which provides a mechanism for passing request scope data between goroutines and canceling goroutine execution. This article will introduce how to use context to implement cross-goroutine communication and provide corresponding code examples.

1. Basic concepts
Before we start using context, we need to understand some basic concepts. In Go language, context is a mechanism used to track the state of goroutine. Context contains a variety of operations that can be used to pass data in the request scope and cancel the execution of goroutine.

Context uses a Context interface, which defines four methods:

1. Deadline() (deadline time.Time, ok bool): Returns a time, representing the deadline of the current context (deadline). If the context has no deadline, the value of ok is false.
2. Done() <-chan struct{}: Returns a channel that will be closed when the context is canceled or the deadline is reached.
3. Err() error: Returns the reason why the context was canceled.
4. Value(key interface{}) interface{}: Returns the value associated with key.

2. Usage Example
We use an example to demonstrate how to use context to achieve cross-goroutine communication. Suppose we have a function that simulates a network request. The request-related code is as follows:

import (
    "context"
    "fmt"
    "time"
)

func simulateNetworkRequest(ctx context.Context) {
    // 模拟一个网络请求，请求耗时5秒
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("网络请求完成")
    case <-ctx.Done():
        fmt.Println("网络请求被取消")
        return
    }
}

In the above code, the simulateNetworkRequest function simulates a network request, which takes 5 seconds. We listen to two channels through the select statement. One is the channel returned by the time.After function, which means that after a period of time, a value will be sent to the channel; the other is the channel returned by the context's Done method, which means that the context is When cancelled, a value will be sent to the channel. If the network request is not completed within 5 seconds and the context is canceled, then we will process it in the second case branch in the select statement.

Next, we use this function in the main function and add some code to demonstrate how to use context to achieve cross-goroutine communication:

import (
    "context"
    "fmt"
    "time"
)

func simulateNetworkRequest(ctx context.Context) {
    // 模拟一个网络请求，请求耗时5秒
    select {
    case <-time.After(5 * time.Second):
        fmt.Println("网络请求完成")
    case <-ctx.Done():
        fmt.Println("网络请求被取消")
        return
    }
}

func main() {
    // 创建一个基于context.Background()的新context
    ctx, cancel := context.WithCancel(context.Background())

    // 启动goroutine执行网络请求
    go simulateNetworkRequest(ctx)

    // 在3秒后取消网络请求
    time.Sleep(3 * time.Second)
    cancel()

    // 等待网络请求执行完毕
    time.Sleep(10 * time.Second)
}

In the above code, we first use context.WithCancel The function creates a new context and returns a function called cancel specifically for cancellation. Then, we started a goroutine to execute the simulateNetworkRequest function, passing the context created above as a parameter. Then, after waiting for 3 seconds in the main function, we call the cancel function to cancel the network request.

The last line of code is used to ensure that after canceling the network request, the main function will not end before the network request is completed. In this way, we can achieve communication between the main function and the goroutine, and be able to cancel the execution of the goroutine when needed.

Summary
Using the context package, we can pass request scope data between different goroutines and cancel the execution of the goroutine when needed. This article demonstrates how to use context to implement cross-goroutine communication through a simple example. I hope readers can understand how to use the context package in Go language through the introduction of this article, so as to better perform concurrent programming.

The above is the detailed content of How to use context to implement cross-goroutine communication in Go. For more information, please follow other related articles on the PHP Chinese website!