Golang copies all values ​​of context

Question content

I have an HTTP server application that serves asynchronous jobs.

-> Request
   --> Do async job with goroutine
<- Response
    -------start goroutine------
       -> Job1
          -> Job1A
          -> Job1B
       -> Job2
       -> Job3

Users can request long-running asynchronous jobs, and the application responds to the request immediately after making goroutine.

I put the request ID, authenticated token, and user information into the request's context.Context. Also, I want to put it under goroutine. However, using the same context for the request context will result in an unexpected cancellation after the response, which is not my expected behavior.

How to generate a new context with all values, independent of the parent request context? Or, is there any other way to ensure that context will not die after bringing in the goroutine's response?

There is an additional question:

Job1 ~ Job3 should be serialized, i.e. Job2 should wait for Job1 and Job3 waitJob2. Also, Job1A and Job1B can run at the same time. If I want to propagate cancellation for a given context, how can I cancel their path(?)? Should I check select statements for all functions?

I understand context The concept of propagating cancellation and early exit without performing meaningless tasks. However, I haven't figured out how to handle this in code. I would be happy if someone could help understand.

Correct answer

The value in the context cannot be discovered. They are not stored as maps, but as context layers, each level potentially providing a different implementation of how values ​​are stored.

However, if you know which values ​​need to be propagated, you can query them and create a new context with those values.

That is, you can implement a new context type that uses values ​​from another context:

type newContext struct {
  context.Context
  values context.Context
}

func (c newContext) Value(key any) any {
  return c.values.Value(key)
}

...
newCtx:=newContext{
  Context: context.Background(),
  values: ctx,
}

This uses the existing value context and a new context for everything else.

Then, start a new goroutine to continue processing requests using the new context.

If you want to create multiple concurrent jobs, you can do this in this goroutine:

go func(ctx context.Context) {
   withCancel, cancel:=context.WithCancel(ctx)
   defer cancel()

   wg:=sync.WaitGroup{}
   wg.Add(2)
   go job1(withCancel,&wg)
   go job2(withCancel,&wg)
   wg.Wait()
}(newCtx)

This way, when the context is canceled, both jobs will receive a cancellation notification. If you want to control the cancellation of job1 and job2 separately:

go func(ctx context.Context) {
   withCancel1, cancel1:=context.WithCancel(ctx)
   defer cancel1()
   withCancel2, cancel2:=context.WithCancel(ctx)
   defer cancel2()

   wg:=sync.WaitGroup{}
   wg.Add(2)
   go job1(withCancel1,&wg)
   go job2(withCancel2,&wg)
   wg.Wait()
}(newCtx)

For consecutive jobs (i.e. job3 finishes after job1), just combine them so they look like one job.

To check if the context was canceled, you can perform a select on the context's Done channel, or simply check:

if ctx.Err()!=nil {
   // Context canceled
}

The above is the detailed content of Golang copies all values ​​of context. For more information, please follow other related articles on the PHP Chinese website!