How Can I Use Contexts in Go Without Cancellation Propagation?

Context without Cancel Propagation: A Deep Dive

Context in Go provides a mechanism to pass arbitrary values along with requests and track cancellations. By default, all contexts share the same cancellation mechanism. However, certain scenarios may require decoupling context propagation from cancellation.

The Need for Non-Canceling Contexts

Consider an HTTP handler that performs tasks beyond the life of the request. After returning a response, the handler may initiate an asynchronous task in a goroutine. This task might require access to context values but must not be terminated if the original request context is canceled.

Creating Custom Non-Canceling Contexts

WithoutCancel was introduced in Go 1.21, providing a simple way to create non-canceling contexts. Using this method, one can obtain a copy of the original context that contains all its stored values but remains independent from its cancellation status.

Implementing Non-Canceling Contexts

Prior to Go 1.21, custom implementations of non-canceling contexts were necessary. The key is to create a type that satisfies the context.Context interface and overrides the following methods to prevent cancellation:

• Deadline(): Always return a zero time and set the second return value to false, indicating no deadline.
• Done(): Return a nil channel, indicating no cancellation is possible.
• Err(): Always return nil, indicating no error has occurred.

In addition, the implementation must store the original context and delegate Value() calls to retrieve the stored values.

Example of Using a Non-Canceling Context

import (
    "context"

    "github.com/mypackage/mycontext"
)

func Handler(ctx context.Context) (interface{}, error) {
    result := doStuff(ctx)
    newContext := mycontext.WithoutCancel(ctx)
    go func() {
        doSomethingElse(newContext)
    }()
    return result
}

Conclusion

By understanding the principles behind non-canceling contexts and leveraging the available tools, developers can create custom solutions or utilize Go's built-in functionality to achieve desired context propagation without cancellation.

The above is the detailed content of How Can I Use Contexts in Go Without Cancellation Propagation?. For more information, please follow other related articles on the PHP Chinese website!