Maison développement back-end Golang Maîtriser le modèle Nursery de Go : améliorez l'efficacité et la robustesse de votre code simultané

Maîtriser le modèle Nursery de Go : améliorez l'efficacité et la robustesse de votre code simultané

Dec 12, 2024 pm 06:38 PM

Mastering Go

Les goroutines et la concurrence structurée changent la donne dans la programmation Go. Ils offrent des moyens puissants de gérer les opérations simultanées, rendant notre code plus efficace et plus robuste. Explorons le modèle Nursery, une technique qui met de l'ordre dans le chaos de la programmation simultanée.

Le modèle Nursery consiste à créer des groupes organisés de tâches. Cela nous donne un meilleur contrôle sur le comportement de nos goroutines et nous aide à gérer les erreurs avec plus de grâce. Considérez-le comme un moyen de garder notre code concurrent bien rangé et gérable.

Pour mettre en œuvre le modèle Nursery, nous commençons par créer un contexte parent qui supervise un groupe de goroutines enfants. Ce contexte parent peut annuler tous ses enfants si quelque chose ne va pas, garantissant ainsi que nous ne laissons aucun fil de discussion en suspens.

Voici un exemple de base de la façon dont nous pourrions mettre en œuvre une crèche simple :

type Nursery struct {
    wg   sync.WaitGroup
    ctx  context.Context
    cancel context.CancelFunc
}

func NewNursery() (*Nursery, context.Context) {
    ctx, cancel := context.WithCancel(context.Background())
    return &Nursery{
        ctx:    ctx,
        cancel: cancel,
    }, ctx
}

func (n *Nursery) Go(f func() error) {
    n.wg.Add(1)
    go func() {
        defer n.wg.Done()
        if err := f(); err != nil {
            n.cancel()
        }
    }()
}

func (n *Nursery) Wait() {
    n.wg.Wait()
}
Copier après la connexion
Copier après la connexion

Cette pépinière nous permet de générer plusieurs goroutines et d'attendre qu'elles soient toutes terminées. Si l'un d'entre eux renvoie une erreur, la crèche annule toutes les autres goroutines.

L'un des principaux avantages du modèle Nursery est la façon dont il gère les paniques. Dans Go, une panique dans une goroutine n'arrête pas automatiquement les autres goroutines. Cela peut entraîner des fuites de ressources et un état incohérent. Avec une pépinière, nous pouvons attraper la panique et nous assurer que toutes les goroutines associées sont correctement arrêtées.

Améliorons notre crèche pour gérer les paniques :

func (n *Nursery) Go(f func() error) {
    n.wg.Add(1)
    go func() {
        defer n.wg.Done()
        defer func() {
            if r := recover(); r != nil {
                fmt.Println("Recovered from panic:", r)
                n.cancel()
            }
        }()
        if err := f(); err != nil {
            n.cancel()
        }
    }()
}
Copier après la connexion
Copier après la connexion

Maintenant, si une goroutine panique, nous l'attraperons, l'enregistrerons et annulerons toutes les autres goroutines de la crèche.

Un autre aspect crucial du modèle Nursery est la gestion des ressources. Dans les systèmes distribués, nous devons souvent coordonner plusieurs opérations qui utilisent des ressources partagées. La crèche peut contribuer à garantir que ces ressources sont correctement acquises et libérées.

Voici un exemple de la façon dont nous pourrions utiliser une pépinière pour gérer les connexions à la base de données :

func main() {
    nursery, ctx := NewNursery()
    defer nursery.Wait()

    dbPool := createDBPool(ctx)
    defer dbPool.Close()

    nursery.Go(func() error {
        return processOrders(ctx, dbPool)
    })

    nursery.Go(func() error {
        return updateInventory(ctx, dbPool)
    })

    nursery.Go(func() error {
        return sendNotifications(ctx, dbPool)
    })
}
Copier après la connexion
Copier après la connexion

Dans cet exemple, nous créons un pool de connexions à la base de données et le transmettons à plusieurs opérations simultanées. La pépinière garantit que si une opération échoue, toutes les autres sont annulées et le pool de bases de données est correctement fermé.

Le modèle Nursery brille vraiment lorsque nous devons limiter la concurrence. Dans de nombreux scénarios réels, nous souhaitons exécuter plusieurs opérations simultanément, mais pas toutes en même temps. Nous pouvons modifier notre pépinière pour inclure un sémaphore qui limite le nombre d'opérations simultanées :

type Nursery struct {
    wg       sync.WaitGroup
    ctx      context.Context
    cancel   context.CancelFunc
    semaphore chan struct{}
}

func NewNursery(maxConcurrency int) (*Nursery, context.Context) {
    ctx, cancel := context.WithCancel(context.Background())
    return &Nursery{
        ctx:      ctx,
        cancel:   cancel,
        semaphore: make(chan struct{}, maxConcurrency),
    }, ctx
}

func (n *Nursery) Go(f func() error) {
    n.wg.Add(1)
    go func() {
        n.semaphore <- struct{}{}
        defer func() {
            <-n.semaphore
            n.wg.Done()
        }()
        if err := f(); err != nil {
            n.cancel()
        }
    }()
}
Copier après la connexion
Copier après la connexion

Cette implémentation garantit que pas plus de goroutines maxConcurrency ne s'exécutent simultanément, évitant ainsi l'épuisement des ressources.

Les délais d'attente sont un autre aspect critique de la programmation simultanée, en particulier dans les systèmes distribués. Nous pouvons facilement ajouter une fonctionnalité de délai d'attente à notre pépinière :

type Nursery struct {
    wg   sync.WaitGroup
    ctx  context.Context
    cancel context.CancelFunc
}

func NewNursery() (*Nursery, context.Context) {
    ctx, cancel := context.WithCancel(context.Background())
    return &Nursery{
        ctx:    ctx,
        cancel: cancel,
    }, ctx
}

func (n *Nursery) Go(f func() error) {
    n.wg.Add(1)
    go func() {
        defer n.wg.Done()
        if err := f(); err != nil {
            n.cancel()
        }
    }()
}

func (n *Nursery) Wait() {
    n.wg.Wait()
}
Copier après la connexion
Copier après la connexion

Cette méthode nous permet de définir un délai d'attente pour chaque opération. Si l'opération ne se termine pas dans le délai imparti, elle est annulée, et toutes les autres opérations en crèche sont également annulées.

Le modèle Nursery devient particulièrement puissant lorsqu'il s'agit de dépendances complexes entre goroutines. Dans de nombreux scénarios réels, certaines opérations dépendent des résultats d’autres. Nous pouvons étendre notre pépinière pour gérer ces dépendances :

func (n *Nursery) Go(f func() error) {
    n.wg.Add(1)
    go func() {
        defer n.wg.Done()
        defer func() {
            if r := recover(); r != nil {
                fmt.Println("Recovered from panic:", r)
                n.cancel()
            }
        }()
        if err := f(); err != nil {
            n.cancel()
        }
    }()
}
Copier après la connexion
Copier après la connexion

Cela nous permet de définir des tâches avec des dépendances, en garantissant qu'elles s'exécutent dans le bon ordre tout en bénéficiant de la concurrence lorsque cela est possible.

Le modèle Nursery ne consiste pas seulement à gérer des goroutines ; il s'agit de créer un code concurrent plus maintenable et plus robuste. En fournissant un moyen structuré de gérer la concurrence, cela nous aide à éviter les pièges courants tels que les fuites de goroutines et les conditions de concurrence.

Dans les microservices et les applications à grande échelle, le modèle Nursery peut changer la donne. Cela nous permet de diviser les flux de travail complexes en unités gérables et annulables. Ceci est particulièrement utile lorsqu'il s'agit de transactions distribuées ou de processus métier complexes qui s'étendent sur plusieurs services.

Voici un exemple de la façon dont nous pourrions utiliser le modèle Nursery dans une architecture de microservice :

func main() {
    nursery, ctx := NewNursery()
    defer nursery.Wait()

    dbPool := createDBPool(ctx)
    defer dbPool.Close()

    nursery.Go(func() error {
        return processOrders(ctx, dbPool)
    })

    nursery.Go(func() error {
        return updateInventory(ctx, dbPool)
    })

    nursery.Go(func() error {
        return sendNotifications(ctx, dbPool)
    })
}
Copier après la connexion
Copier après la connexion

Dans cet exemple, nous traitons une commande en utilisant plusieurs opérations simultanées. Nous mettons à jour l'inventaire, traitons le paiement et expédions la commande simultanément. Nous avons également une goroutine qui attend la fin de toutes ces opérations avant d'envoyer un email de confirmation. Si une opération échoue ou expire, toutes les autres sont annulées.

Le modèle Nursery brille également en matière de gestion des erreurs dans le code concurrent. La gestion traditionnelle des erreurs peut devenir complexe lorsqu’il s’agit de plusieurs goroutines. La crèche offre un moyen centralisé de gérer les erreurs :

type Nursery struct {
    wg       sync.WaitGroup
    ctx      context.Context
    cancel   context.CancelFunc
    semaphore chan struct{}
}

func NewNursery(maxConcurrency int) (*Nursery, context.Context) {
    ctx, cancel := context.WithCancel(context.Background())
    return &Nursery{
        ctx:      ctx,
        cancel:   cancel,
        semaphore: make(chan struct{}, maxConcurrency),
    }, ctx
}

func (n *Nursery) Go(f func() error) {
    n.wg.Add(1)
    go func() {
        n.semaphore <- struct{}{}
        defer func() {
            <-n.semaphore
            n.wg.Done()
        }()
        if err := f(); err != nil {
            n.cancel()
        }
    }()
}
Copier après la connexion
Copier après la connexion

Cette implémentation collecte toutes les erreurs qui se produisent dans les goroutines de la crèche. Lorsque nous appelons Wait(), il renvoie une seule erreur qui encapsule toutes les erreurs individuelles.

Le modèle Nursery ne concerne pas seulement la gestion des goroutines ; il s'agit de créer des systèmes plus résilients. En fournissant une manière structurée de gérer la simultanéité, il nous aide à créer des applications capables de gérer avec élégance les échecs et les situations inattendues.

En conclusion, le pattern Nursery est un outil puissant pour gérer la concurrence dans Go. Il fournit une approche structurée pour générer et gérer des goroutines, gérer les erreurs et les paniques et coordonner des flux de travail complexes. En implémentant ce modèle, nous pouvons créer un code concurrent plus robuste, maintenable et efficace, en particulier dans les applications à grande échelle et les architectures de microservices. À mesure que nous continuons à construire des systèmes distribués plus complexes, des modèles comme celui-ci deviendront de plus en plus importants dans notre boîte à outils de programmation Go.


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!

Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Outils d'IA chauds

Undresser.AI Undress

Undresser.AI Undress

Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover

AI Clothes Remover

Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool

Undress AI Tool

Images de déshabillage gratuites

Clothoff.io

Clothoff.io

Dissolvant de vêtements AI

Video Face Swap

Video Face Swap

Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

<🎜>: Bubble Gum Simulator Infinity - Comment obtenir et utiliser les clés royales
4 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
<🎜>: Grow A Garden - Guide de mutation complet
3 Il y a quelques semaines By DDD
Nordhold: Système de fusion, expliqué
4 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
Mandragora: Whispers of the Witch Tree - Comment déverrouiller le grappin
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌

Outils chauds

Bloc-notes++7.3.1

Bloc-notes++7.3.1

Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise

SublimeText3 version chinoise

Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1

Envoyer Studio 13.0.1

Puissant environnement de développement intégré PHP

Dreamweaver CS6

Dreamweaver CS6

Outils de développement Web visuel

SublimeText3 version Mac

SublimeText3 version Mac

Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

Tutoriel Java
1672
14
Tutoriel PHP
1276
29
Tutoriel C#
1256
24
Golang vs Python: performance et évolutivité Golang vs Python: performance et évolutivité Apr 19, 2025 am 12:18 AM

Golang est meilleur que Python en termes de performances et d'évolutivité. 1) Les caractéristiques de type compilation de Golang et le modèle de concurrence efficace le font bien fonctionner dans des scénarios de concurrence élevés. 2) Python, en tant que langue interprétée, s'exécute lentement, mais peut optimiser les performances via des outils tels que Cython.

Golang et C: concurrence vs vitesse brute Golang et C: concurrence vs vitesse brute Apr 21, 2025 am 12:16 AM

Golang est meilleur que C en concurrence, tandis que C est meilleur que Golang en vitesse brute. 1) Golang obtient une concurrence efficace par le goroutine et le canal, ce qui convient à la gestion d'un grand nombre de tâches simultanées. 2) C Grâce à l'optimisation du compilateur et à la bibliothèque standard, il offre des performances élevées près du matériel, adaptées aux applications qui nécessitent une optimisation extrême.

Partage avec Go: un guide du débutant Partage avec Go: un guide du débutant Apr 26, 2025 am 12:21 AM

GOISIDEALFORBEGINNERNERS et combinant pour pourcloudandNetWorkServicesDuetOtssimplicity, Efficiency, andCurrencyFeatures.1) InstallgofromTheofficialwebsiteandverifywith'goversion'..2)

Golang vs C: Performance et comparaison de la vitesse Golang vs C: Performance et comparaison de la vitesse Apr 21, 2025 am 12:13 AM

Golang convient au développement rapide et aux scénarios simultanés, et C convient aux scénarios où des performances extrêmes et un contrôle de bas niveau sont nécessaires. 1) Golang améliore les performances grâce à des mécanismes de collecte et de concurrence des ordures, et convient au développement de services Web à haute concurrence. 2) C réalise les performances ultimes grâce à la gestion manuelle de la mémoire et à l'optimisation du compilateur, et convient au développement du système intégré.

Golang vs Python: différences et similitudes clés Golang vs Python: différences et similitudes clés Apr 17, 2025 am 12:15 AM

Golang et Python ont chacun leurs propres avantages: Golang convient aux performances élevées et à la programmation simultanée, tandis que Python convient à la science des données et au développement Web. Golang est connu pour son modèle de concurrence et ses performances efficaces, tandis que Python est connu pour sa syntaxe concise et son écosystème de bibliothèque riche.

Golang et C: les compromis en performance Golang et C: les compromis en performance Apr 17, 2025 am 12:18 AM

Les différences de performance entre Golang et C se reflètent principalement dans la gestion de la mémoire, l'optimisation de la compilation et l'efficacité du temps d'exécution. 1) Le mécanisme de collecte des ordures de Golang est pratique mais peut affecter les performances, 2) la gestion manuelle de C et l'optimisation du compilateur sont plus efficaces dans l'informatique récursive.

La course de performance: Golang vs C La course de performance: Golang vs C Apr 16, 2025 am 12:07 AM

Golang et C ont chacun leurs propres avantages dans les compétitions de performance: 1) Golang convient à une concurrence élevée et à un développement rapide, et 2) C fournit des performances plus élevées et un contrôle fin. La sélection doit être basée sur les exigences du projet et la pile de technologie d'équipe.

Golang contre Python: les avantages et les inconvénients Golang contre Python: les avantages et les inconvénients Apr 21, 2025 am 12:17 AM

GolangisidealforBuildingsCalableSystemsDuetoitSefficiency and Concurrency, tandis que les Implicites de l'Indrecosystem et le Golang'sDesignenCourageSlecElNCORES

See all articles