关于Golang context包中cancelCtx嵌入接口字段赋值的疑问

Great question — this gets into some of the lower-level details of how Go interfaces work, which is key to understanding how the context package operates. Let's break this down clearly.

First, let's recap the code you're asking about:

// Canceling this context releases resources associated with it, so code should
// call cancel as soon as the operations running in this Context complete.
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) {
	c := newCancelCtx(parent)
	propagateCancel(parent, &c)
	return &c, func() { c.cancel(true, Canceled) }
}

// newCancelCtx returns an initialized cancelCtx.
func newCancelCtx(parent Context) cancelCtx {
	return cancelCtx{Context: parent}
}

1. What happens when we assign parent Context to cancelCtx.Context? #

In Go, interface values are actually small structs with two fields:

• A pointer to type information (describing the concrete type that implements the interface)
• A pointer to the actual concrete data that the interface wraps

When you assign one interface value to another (like cancelCtx.Context = parent), you're making a shallow copy of this interface struct. You're not copying the underlying concrete Context instance — you're copying the two pointers that point to that instance.

2. Does cancelCtx.Context hold a pointer to the parent interface? #

Not exactly — it holds a copy of the parent interface itself, which contains pointers to the parent's underlying concrete data. Let's clarify:

• If your parent Context is a concrete type like *cancelCtx, the copied interface value in cancelCtx.Context will have the same type pointer (pointing to *cancelCtx type info) and the same data pointer (pointing to the original parent cancelCtx instance).
• This means the child cancelCtx shares access to the same parent Context instance as the original parent parameter.

3. Why is this design choice important? #

The context package is built around a tree-like hierarchy where cancellation signals propagate from parent to children. Using a shallow copy of the interface:

• Saves memory (no need to duplicate entire Context instances)
• Ensures that when a parent is canceled, all children that reference it can receive that signal (since they're pointing to the same underlying instance)
• Maintains the intended propagation behavior of the context system

To sum up: #

• The assignment cancelCtx{Context: parent} is a shallow copy — it copies the interface value (the two pointers) but not the underlying Context data.
• The cancelCtx.Context field does not hold a pointer to the parent interface variable, but its copied interface value contains pointers that reference the same underlying parent Context instance as the original parent parameter.

内容的提问来源于stack exchange，提问作者PatriackLiang