À propos de la programmation simultanée Mutex in Go

                                                     

Ce qui suit vous est présenté par la colonne du didacticiel golang Go Mutex pour la programmation simultanée, j'espère que cela sera utile aux amis de besoin!

Rappel amical : Cet article prend environ 5 minutes et 45 secondes à lire. Veuillez me donner quelques conseils sur d'éventuelles lacunes. Merci d'avoir lu.

Des problèmes d'accès simultané surviennent souvent dans la conception de nos projets à grande échelle les plus courants. La concurrence consiste à résoudre l'exactitude des données et à garantir que les données de la même section critique ne peuvent être exploitées que par un seul thread. est utilisé dans la vie quotidienne Il existe également de nombreux scénarios simultanés :

• Compteur : Le résultat du compteur est inexact
• Flash Kill System ; : En raison du grand nombre de visites en même temps, entraînant une survente
• Anormalité du compte utilisateur : découvert du compte causé par un paiement en même temps ; 🎜>Anomalie des données du tampon
 : causée par la mise à jour du tampon Les données sont désordonnées.
• Ce qui précède concerne tous les problèmes d'exactitude des données causés par la concurrence. La solution consiste à utiliser le
verrouillage mutex

, qui est la primitive de concurrence Mutex à décrire dans la programmation simultanée d'aujourd'hui.

Mécanisme de mise en œuvre

Verrouillage Mutex Mutex est un mécanisme de contrôle de concurrence établi pour éviter la concurrence de concurrence, et il existe un concept de « section critique ».

Dans le processus de programmation simultanée, si certaines ressources ou variables du programme seront consultées ou modifiées simultanément, afin d'éviter l'inexactitude des données causée par un accès simultané, cette partie du programme doit être protégé d'abord puis exploité, supprimez la protection une fois l'opération terminée, cette partie du programme protégé est appelée

section critique

.

Utilisez un verrou mutex pour limiter la section critique à un seul thread à la fois

Si la section critique est détenue par un thread à ce moment-là, alors. d'autres threads veulent y entrer. Lorsque la section critique est atteinte, il échouera ou attendra que le verrou soit libéré. ​​Le thread détenant cette section critique se terminera et les autres threads auront la possibilité d'obtenir cette section critique.

Diagramme de section critique Go mutex

Mutex est la primitive de synchronisation la plus utilisée dans le langage Go, également connue sous le nom de primitive de concurrence,

solution Le le but est de lire et d'écrire simultanément des ressources partagées pour éviter les problèmes de course aux données

.

Utilisation de base

Mutex propose deux méthodes, Lock et Unlock : lorsque vous entrez dans la section critique, utilisez la méthode Lock pour verrouiller, et lorsque vous quittez la section critique , utilisez la méthode Unlock pour libérer le verrou.

type Locker interface {
    Lock()
    Unlock()}func(m *Mutex)Lock()func(m *Mutex)Unlock()

Lorsqu'une goroutine appelle la méthode Lock pour acquérir le verrou, d'autres goroutines bloqueront l'appel Lock jusqu'à ce que la goroutine qui acquiert actuellement le verrou libère le verrou.

Ce qui suit est un exemple de compteur, qui est exécuté par 100 goroutines pour accumuler le compteur, et le résultat final est :

package mainimport (
    "fmt"
    "sync")func main() {
    var mu sync.Mutex
    countNum := 0

    // 确认辅助变量是否都执行完成
    var wg sync.WaitGroup    // wg 添加数目要和 创建的协程数量保持一致
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go func() {
            defer wg.Done()
            for j := 0; j < 1000; j++ {
                mu.Lock()
                countNum++
                mu.Unlock()
            }
        }()
    }
    wg.Wait()
    fmt.Printf("countNum: %d", countNum)}

Réel use

Souvent, Mutex n'est pas utilisé seul, mais est utilisé imbriqué dans une structure dans le cadre de la structure Si la structure intégrée a plusieurs champs, nous plaçons généralement le Mutex dans le champ à contrôler. . ci-dessus, puis utilisez des espaces pour séparer les champs.

Vous pouvez même résumer la logique d'acquisition de verrous, de libération de verrous et de comptage par un dans une méthode.

package mainimport (
    "fmt"
    "sync")// 线程安全的计数器type Counter struct {
    CounterType int
    Name        string

    mu    sync.Mutex
    count uint64}// 加一方法func (c *Counter) Incr() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++}// 取数值方法 线程也需要受保护func (c *Counter) Count() uint64 {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count}func main() {
    // 定义一个计数器
    var counter Counter    var wg sync.WaitGroup
    wg.Add(100)

    for i := 0; i < 100; i++ {
        go func() {
            defer wg.Done()
            for j := 0; j < 1000; j++ {
                counter.Incr()
            }
        }()
    }
    wg.Wait()

    fmt.Printf("%d\n", counter.Count())}

Questions de réflexion

Q : Vous savez déjà que si Mutex a été verrouillé par un goroutine, les autres goroutines en attente ne peuvent qu'attendre indéfiniment. Ainsi, une fois le verrou libéré, lequel des goroutines en attente obtiendra le Mutex en premier ?

A : FIFO, stratégie du premier arrivé, premier servi. Dans la planification des goroutines de Go, une file d'attente est maintenue pour garantir l'exécution de la goroutine. Lorsque la goroutine qui acquiert le verrou termine l'opération de la section critique, elle sera libérée. . Lock, la goroutine classée première dans la file d'attente obtiendra le verrou pour faire fonctionner la section critique.

                                                                                            

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!