Concurrence de Master Go : les secrets de propagation et d'annulation du contexte révélés

Le modèle de concurrence de Go change la donne, mais la gestion d'opérations simultanées complexes peut s'avérer délicate. C'est là qu'interviennent la propagation et l'annulation du contexte. Ces outils puissants nous permettent de créer des opérations robustes et annulables qui s'étendent sur plusieurs goroutines et même sur les limites du réseau.

Commençons par les bases. Le package de contexte fournit un moyen de transmettre les délais, les signaux d'annulation et les valeurs de portée de demande au-delà des limites de l'API et entre les processus. C'est la sauce secrète pour contrôler les opérations de longue durée et arrêter les services en douceur.

Voici un exemple simple d'utilisation du contexte pour l'annulation :

func longRunningOperation(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // Do some work
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    if err := longRunningOperation(ctx); err != nil {
        log.Printf("Operation cancelled: %v", err)
    }
}

Dans cet exemple, nous créons un contexte avec un délai d'attente de 5 secondes. Si l'opération ne se termine pas dans ce délai, elle est automatiquement annulée.

Mais le contexte ne concerne pas uniquement les délais d'attente. Nous pouvons l'utiliser pour propager des signaux d'annulation sur plusieurs goroutines. Ceci est incroyablement utile pour gérer des flux de travail complexes.

Considérons un scénario dans lequel nous construisons un système de transactions distribuées. Nous pouvons avoir plusieurs microservices impliqués dans une seule transaction, et nous devons nous assurer que si une partie échoue, la transaction entière est annulée.

Voici comment nous pourrions structurer cela en utilisant le contexte :

func performTransaction(ctx context.Context) error {
    // Start the transaction
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback() // Will be no-op if tx.Commit() is called

    // Perform multiple operations
    if err := operation1(ctx); err != nil {
        return err
    }
    if err := operation2(ctx); err != nil {
        return err
    }
    if err := operation3(ctx); err != nil {
        return err
    }

    // If we've made it this far, commit the transaction
    return tx.Commit()
}

func operation1(ctx context.Context) error {
    // Make an HTTP request to another service
    req, err := http.NewRequestWithContext(ctx, "GET", "http://service1.example.com", nil)
    if err != nil {
        return err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    // Process the response...
    return nil
}

Dans cet exemple, nous utilisons le contexte pour propager l'annulation à la fois dans les opérations de base de données et dans les requêtes HTTP. Si le contexte est annulé à tout moment (en raison d'un délai d'attente ou d'une annulation explicite), toutes les opérations seront terminées et les ressources seront nettoyées.

Mais que se passe-t-il si nous avons besoin d'un contrôle plus précis sur l'annulation ? C'est là qu'interviennent les types de contexte personnalisés. Nous pouvons créer nos propres types de contexte qui transportent des signaux d'annulation spécifiques au domaine.

Voici un exemple de contexte personnalisé portant une valeur « prioritaire » :

type priorityKey struct{}

func WithPriority(ctx context.Context, priority int) context.Context {
    return context.WithValue(ctx, priorityKey{}, priority)
}

func GetPriority(ctx context.Context) (int, bool) {
    priority, ok := ctx.Value(priorityKey{}).(int)
    return priority, ok
}

func priorityAwareOperation(ctx context.Context) error {
    priority, ok := GetPriority(ctx)
    if !ok {
        priority = 0 // Default priority
    }

    // Use the priority to make decisions...
    switch priority {
    case 1:
        // High priority operation
    case 2:
        // Medium priority operation
    default:
        // Low priority operation
    }

    return nil
}

Ce contexte personnalisé nous permet de propager les informations de priorité ainsi que les signaux d'annulation, nous donnant encore plus de contrôle sur nos opérations simultanées.

Parlons maintenant de l'arrêt progressif. Lorsque nous construisons des services de longue durée, il est crucial de gérer correctement les signaux d'arrêt pour garantir que nous ne laissons aucune opération suspendue ou aucune ressource non nettoyée.

Voici comment implémenter un arrêt progressif en utilisant le contexte :

func main() {
    // Create a context that's cancelled when we receive an interrupt signal
    ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
    defer cancel()

    // Start our main service loop
    errChan := make(chan error, 1)
    go func() {
        errChan <- runService(ctx)
    }()

    // Wait for either the service to exit or a cancellation signal
    select {
    case err := <-errChan:
        if err != nil {
            log.Printf("Service exited with error: %v", err)
        }
    case <-ctx.Done():
        log.Println("Received shutdown signal. Gracefully shutting down...")
        // Perform any necessary cleanup
        // Wait for ongoing operations to complete (with a timeout)
        cleanupCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
        defer cancel()
        if err := performCleanup(cleanupCtx); err != nil {
            log.Printf("Cleanup error: %v", err)
        }
    }
}

func runService(ctx context.Context) error {
    // Run your service here, respecting the context for cancellation
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // Do some work
        }
    }
}

func performCleanup(ctx context.Context) error {
    // Perform any necessary cleanup operations
    // This could include closing database connections, flushing buffers, etc.
    return nil
}

Cette configuration garantit que notre service peut s'arrêter correctement lorsqu'il reçoit un signal d'interruption, ce qui lui laisse le temps de nettoyer les ressources et de terminer toutes les opérations en cours.

L'un des aspects les plus puissants du système contextuel de Go est sa capacité à propager l'annulation au-delà des frontières du réseau. Ceci est particulièrement utile lors de la création de systèmes distribués où les opérations peuvent s'étendre sur plusieurs services.

Regardons un exemple de la façon dont nous pourrions implémenter cela dans une architecture de microservices :

func longRunningOperation(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // Do some work
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    if err := longRunningOperation(ctx); err != nil {
        log.Printf("Operation cancelled: %v", err)
    }
}

Dans cet exemple, nous créons un contexte avec un délai d'attente basé sur un paramètre de requête. Ce contexte est ensuite propagé à travers tous les appels API ultérieurs. Si le délai d'attente est atteint, toutes les opérations en cours sont annulées et nous renvoyons une erreur au client.

Ce modèle garantit que nous n'avons pas d'opérations « incontrôlables » qui se poursuivent longtemps après que le client a renoncé à attendre une réponse. Il s'agit d'un élément clé de la création de systèmes distribués réactifs et économes en ressources.

La gestion des erreurs dans les systèmes concurrents peut être délicate, mais le contexte peut également aider ici. En utilisant le contexte, nous pouvons garantir que les erreurs se propagent correctement et que les ressources sont nettoyées même lorsque des erreurs se produisent.

Voici un exemple de la façon dont nous pourrions gérer les erreurs dans une opération simultanée :

func performTransaction(ctx context.Context) error {
    // Start the transaction
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback() // Will be no-op if tx.Commit() is called

    // Perform multiple operations
    if err := operation1(ctx); err != nil {
        return err
    }
    if err := operation2(ctx); err != nil {
        return err
    }
    if err := operation3(ctx); err != nil {
        return err
    }

    // If we've made it this far, commit the transaction
    return tx.Commit()
}

func operation1(ctx context.Context) error {
    // Make an HTTP request to another service
    req, err := http.NewRequestWithContext(ctx, "GET", "http://service1.example.com", nil)
    if err != nil {
        return err
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    // Process the response...
    return nil
}

Dans cet exemple, nous utilisons un canal pour communiquer les erreurs de la goroutine à la fonction principale. Nous vérifions également le contexte d'annulation. Cela garantit que nous traitons à la fois les erreurs de l'opération elle-même et les annulations du contexte.

Un aspect souvent négligé du contexte est sa capacité à transporter des valeurs adaptées à la requête. Cela peut être incroyablement utile pour propager des éléments tels que des identifiants de requête, des jetons d'authentification ou d'autres métadonnées au-delà des limites de l'API.

Voici un exemple de la façon dont nous pourrions utiliser ceci :

type priorityKey struct{}

func WithPriority(ctx context.Context, priority int) context.Context {
    return context.WithValue(ctx, priorityKey{}, priority)
}

func GetPriority(ctx context.Context) (int, bool) {
    priority, ok := ctx.Value(priorityKey{}).(int)
    return priority, ok
}

func priorityAwareOperation(ctx context.Context) error {
    priority, ok := GetPriority(ctx)
    if !ok {
        priority = 0 // Default priority
    }

    // Use the priority to make decisions...
    switch priority {
    case 1:
        // High priority operation
    case 2:
        // Medium priority operation
    default:
        // Low priority operation
    }

    return nil
}

Dans cet exemple, nous utilisons un middleware pour ajouter un ID de demande au contexte. Cet ID de demande peut ensuite être récupéré et utilisé dans tous les gestionnaires ou fonctions ultérieurs qui reçoivent ce contexte.

En conclusion, il convient de noter que même si le contexte est un outil puissant, ce n'est pas une solution miracle. La surutilisation du contexte peut conduire à un code difficile à comprendre et à maintenir. Il est important d'utiliser le contexte judicieusement et de concevoir vos API avec soin.

N'oubliez pas que l'utilisation principale du contexte doit être destinée à transmettre les délais, les signaux d'annulation et les valeurs liées aux requêtes au-delà des limites de l'API. Il ne s'agit pas d'un mécanisme général permettant de transmettre des paramètres facultatifs aux fonctions.

En conclusion, la maîtrise du modèle de concurrence de Go, y compris la propagation et l'annulation du contexte, est essentielle pour créer des applications robustes, efficaces et évolutives. En tirant parti de ces outils, nous pouvons créer des systèmes capables de gérer avec élégance des flux de travail complexes, de gérer efficacement les ressources et de répondre intelligemment aux conditions changeantes. Alors que nous continuons à repousser les limites de ce qui est possible avec la programmation simultanée, ces techniques deviendront encore plus cruciales dans notre boîte à outils.

---

Nos créations

N'oubliez pas de consulter nos créations :

Centre des investisseurs | Vie intelligente | Époques & Échos | Mystères déroutants | Hindutva | Développeur Élite | Écoles JS

---

Nous sommes sur Medium

Tech Koala Insights | Epoques & Echos Monde | Support Central des Investisseurs | Mystères déroutants Medium | Sciences & Epoques Medium | Hindutva moderne

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!