Comment créer un contexte dans Go qui ignore l'annulation ?

Création d'un contexte sans annulation de propagation dans Go

Dans Go, un contexte contient des informations liées à l'exécution telles que les délais et les jetons d'annulation. Cependant, certains scénarios peuvent nécessiter la création d'un contexte distinct qui partage les mêmes données mais n'est pas affecté par l'annulation du contexte d'origine.

Énoncé du problème

La tâche à accomplir est de créer un « clone » " (ou copie) d'un ctx de contexte Go tel que :

• Il contient toutes les valeurs stockées dans l'original ctx.
• Il n'est pas annulé lorsque ctx est annulé.

Solution

Puisque context.Context est une interface, vous pouvez définir votre propre implémentation qui ignore signaux d’annulation. Voici un exemple :

package main

import (
    "context"
    "time"
)

type noCancel struct {
    ctx context.Context
}

func (c noCancel) Deadline() (time.Time, bool)       { return time.Time{}, false }
func (c noCancel) Done() <-chan struct{}             { return nil }
func (c noCancel) Err() error                        { return nil }
func (c noCancel) Value(key interface{}) interface{} { return c.ctx.Value(key) }

// WithoutCancel returns a context that is never canceled.
func WithoutCancel(ctx context.Context) context.Context {
    return noCancel{ctx: ctx}
}

func main() {
    ctx := context.Background()
    clone := WithoutCancel(ctx)

    // Create a goroutine using the clone context.
    go func() {
        // This goroutine will never be interrupted by cancelations on `ctx`.
        time.Sleep(time.Second)
    }()
}

Utilisation

Vous pouvez utiliser la fonction WithoutCancel pour créer un contexte de clonage dans n'importe quelle fonction ou méthode :

func f(ctx context.Context) {
    // Create a non-cancelable clone.
    clone := WithoutCancel(ctx)

    // Start an async task using the clone context.
    go func() {
        // This goroutine will not be affected by cancellations on `ctx`.
    }()
}

Conclusion

Cette solution offre un moyen simple de créer un contexte qui n'est jamais annulé, vous permettant d'effectuer des tâches asynchrones qui survivent au contexte d'origine. Ceci est particulièrement utile lorsque vous souhaitez éviter l'arrêt prématuré des tâches en arrière-plan en raison d'une annulation de contexte.

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!