Golang copie toutes les valeurs de contexte

Contenu de la question

J'ai une application serveur HTTP qui sert des tâches asynchrones.

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

Les utilisateurs peuvent demander des tâches asynchrones de longue durée et l'application répond à la demande immédiatement après make goroutine.

J'ai mis l'ID de la demande, le jeton authentifié et les informations utilisateur dans la demande context.Context 中。而且，我想把它放在 goroutine 下。但是，对请求 context 使用相同的 context, ce qui provoque une annulation inattendue après la réponse, ce qui n'est pas mon comportement prévu.

Comment générer de nouveaux context，独立于父请求 context？或者，还有其他方法可以保证 context avec toutes les valeurs sans mourir après avoir apporté la réponse de goroutine ?

Et une question bonus :

Annulation de

Job1 ~ Job3 应该被序列化，即 Job2 应该等待 Job1 和 Job3 等待 Job2。并且，Job1A 和 Job1B 可以同时运行。如果我想传播给定 context, comment puis-je annuler leur parcours(?) ? Dois-je vérifier les instructions select pour toutes les fonctions ?

Je comprends context propager le concept d'annulation et de sortie anticipée sans effectuer de tâches inutiles. Cependant, je n'ai pas compris comment gérer cela dans le code. Je serais heureux si quelqu'un pouvait m'aider à comprendre.

Bonne réponse

La valeur dans le contexte ne peut pas être découverte. Ils ne sont pas stockés sous forme de cartes, mais sous forme de couches de contexte, chaque niveau fournissant potentiellement une implémentation différente de la manière dont les valeurs sont stockées.

Cependant, si vous savez quelles valeurs doivent être propagées, vous pouvez les interroger et créer un nouveau contexte avec ces valeurs.

Autrement dit, vous pouvez implémenter un nouveau type de contexte qui utilise les valeurs d'un autre contexte :

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,
}

Cela utilise le contexte de valeur existant et un nouveau contexte pour tout le reste.

Ensuite, démarrez une nouvelle goroutine pour continuer à traiter les demandes en utilisant le nouveau contexte.

Si vous souhaitez créer plusieurs tâches simultanées, vous pouvez le faire dans cette 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)

De cette façon, lorsque le contexte est annulé, les deux tâches recevront une notification d'annulation. Si vous souhaitez contrôler l'annulation de job1 et job2 séparément :

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)

Pour les tâches consécutives (c'est-à-dire que la tâche 3 se termine après la tâche 1), combinez-les simplement pour qu'elles ressemblent à une seule tâche.

Pour vérifier si un contexte a été annulé, vous pouvez le faire dans celui du contexte Done 通道上执行 select, ou simplement vérifier :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!