Modèles sécurisés pour la concurrence dans Go : comment procéder ?

Les modèles de sécurité de la concurrence dans Go sont un problème clé pour les programmes qui doivent fonctionner dans un environnement simultané, assurer la sécurité des données est crucial. Lorsqu'il s'agit de concurrence, nous devons prendre certaines mesures pour protéger les ressources partagées et éviter les conditions de concurrence et les courses aux données. Dans cet article, je vais vous présenter quelques modèles de sécurité de la concurrence couramment utilisés, vous aider à comprendre le concept de sécurité de la concurrence et vous fournir quelques suggestions pratiques. Les développeurs débutants comme expérimentés peuvent en bénéficier. Voyons comment assurer la sécurité de la concurrence dans Go !

Contenu de la question

J'ai le numéro de téléphone suivant :

import (
  "text/template"
)

//...

template.new(filepath.base(name)).funcs(templatefunctions).parse(string(asset))

Appelez simultanément dans plusieurs routines Go, Cela conduit à la panique suivante :

fatal error: concurrent map iteration and map write

Voici le traçage :

goroutine 140 [running]:
text/template.addvaluefuncs(0xc00188e000?, 0xc00188e000?)
        [...]/go/src/text/template/funcs.go:88 +0x76
[...]/modules/template.loadembeddedtemplates({0x38ff6cb?, 0xc001cf8060?})
        [...]/src/modules/template/configbased.go:163 +0x749

src/modules/template/configbased.go:163 lignes sur cité ci-dessus. C'est template.new(...).

Les fonctions environnantes sont appelées simultanément depuis la goroutine.

Voici le code de go/src/text/template/funcs.go:88 Si ça peut aider :

// addvaluefuncs adds to values the functions in funcs, converting them to reflect.values.
func addvaluefuncs(out map[string]reflect.value, in funcmap) {
    for name, fn := range in {
        if !goodname(name) {
            panic(fmt.errorf("function name %q is not a valid identifier", name))
        }
        v := reflect.valueof(fn)
        if v.kind() != reflect.func {
            panic("value for " + name + " not a function")
        }
        if !goodfunc(v.type()) {
            panic(fmt.errorf("can't install method/function %q with %d results", name, v.type().numout()))
        }
        out[name] = v
    }
}

Si template.new est sécurisé pour la concurrence, pourquoi cette ligne génère-t-elle cette panique et comment dois-je la gérer correctement ?

Mise à jour.

Code pour la fonction ennuyeuseloadembeddedtemplates :

func loadEmbeddedTemplates(templateFile string) (*template.Template, error) {
    var t *template.Template

    templateFile = filepath.Join("share", "templates", filepath.Base(templateFile))
    dir := filepath.Dir(templateFile)
    names := assets.GetAssetNames()

    // All templates except + the last one at the end
    filteredNames := []string{}

    for _, name := range names {
        if !strings.HasPrefix(name, dir+"/") || !strings.HasSuffix(name, ".tmpl") {
            continue
        }

        if name != templateFile {
            filteredNames = append(filteredNames, name)
        }
    }

    filteredNames = append(filteredNames, templateFile)

    for _, name := range filteredNames {
        asset, err := assets.GetAsset(name)
        if err != nil {
            return nil, err
        }

        if t == nil {
            t, err = template.New(filepath.Base(name)).Funcs(templateFunctions).Parse(string(asset))
        } else {
            t, err = t.New(filepath.Base(name)).Parse(string(asset))
        }

        if err != nil {
            return nil, err
        }
    }

    return t, nil
}

Cette fonction charge simplement tous les modèles dans share/templates/ dans l'ordre share/templates/ 中的所有模板

解决方法

您的 loadEmbeddedTemplates() 函数访问 templateFunctions 变量，将其传递给 Template.Funcs()

Solution de contournement

Votre fonction loadEmbeddedTemplates() accède à la variable templateFunctions, en le passant à

qui le lira évidemment (le parcourra). Template.Funcs()

Et vous pourriez le remplir dans un autre goroutine en même temps. D'où l'erreur d'écriture de carte simultanée. L'accès à celui-ci doit être synchronisé. 🎜 🎜Si possible, remplissez-le avant de commencer à l'utiliser (transmettez-le à 🎜). De cette façon, aucune synchronisation ou verrouillage supplémentaire n'est requis (la lecture seule simultanée est toujours possible). 🎜

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!