Un article présentant les méthodes de synchronisation dans Golang

Golang est un langage qui prend en charge la programmation simultanée, mais dans la programmation simultanée, une incohérence des données peut facilement se produire. Par conséquent, dans Golang, nous devons utiliser des méthodes de synchronisation pour garantir l'exactitude et la fiabilité du programme. Cet article présentera la méthode de synchronisation dans Golang.

1. Verrouillage mutex

Le verrouillage mutex est l'un des mécanismes de synchronisation les plus couramment utilisés. Les ressources partagées peuvent être verrouillées via des verrous mutex, garantissant qu'un seul thread peut accéder aux ressources partagées en même temps, évitant ainsi les conditions de concurrence. Dans Golang, les verrous mutex sont implémentés via sync.Mutex dans la bibliothèque standard. Voici un exemple de code pour un verrou mutex :

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var lock sync.Mutex
    var wg sync.WaitGroup

    var count int

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            lock.Lock() // 加锁
            defer lock.Unlock() // 解锁

            count++
            time.Sleep(time.Second)
            fmt.Println(count)
            wg.Done()
        }()
    }

    wg.Wait()
}

2. Verrouillage en lecture-écriture

Le verrou en lecture-écriture est un verrou mutex spécial qui permet à plusieurs threads de lire des ressources partagées en même temps, mais lors de l'écriture, , un seul thread peut accéder à la ressource partagée en même temps. Dans Golang, les verrous en lecture-écriture sont implémentés via sync.RWMutex dans la bibliothèque standard. Voici un exemple de code pour un verrou en lecture-écriture :

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var lock sync.RWMutex
    var wg sync.WaitGroup

    var count int

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(idx int) {
            // 多个线程读操作可以同时进行
            lock.RLock()
            fmt.Printf("读协程%d，count=%d\n", idx, count)
            lock.RUnlock()

            // 一个线程写操作时，其它线程无法读写
            lock.Lock()
            count++
            fmt.Printf("写协程%d，count=%d\n", idx, count)
            time.Sleep(time.Second)
            lock.Unlock()

            wg.Done()
        }(i)
    }

    wg.Wait()
}

3. Variable de condition

La variable de condition est un mécanisme de synchronisation qui permet aux threads de se synchroniser en fonction de conditions spécifiques. Dans Golang, les variables de condition sont implémentées via sync.Cond dans la bibliothèque standard. Voici un exemple de code pour une variable de condition :

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var lock sync.Mutex
    var wg sync.WaitGroup
    var cond = sync.NewCond(&lock)

    done := false

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(idx int) {
            lock.Lock()
            for !done {
                cond.Wait() // 等待通知
            }
            fmt.Printf("协程%d收到通知\n", idx)
            lock.Unlock()

            wg.Done()
        }(i)
    }

    time.Sleep(time.Second)

    lock.Lock()
    done = true // 向所有协程发送通知
    cond.Broadcast()
    lock.Unlock()

    wg.Wait()
}

4. Opération atomique

L'opération atomique est une opération qui peut lire et écrire des données en mémoire sans verrouillage. Dans Golang, les opérations atomiques sont implémentées via sync/atomic dans la bibliothèque standard. Voici un exemple de code pour une opération atomique :

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var value int32
    atomic.StoreInt32(&value, 10)
    fmt.Println(atomic.LoadInt32(&value))

    atomic.AddInt32(&value, 5)
    fmt.Println(atomic.LoadInt32(&value))

    atomic.CompareAndSwapInt32(&value, 15, 20) // 如果value等于15，则将其更新为20
    fmt.Println(atomic.LoadInt32(&value))
}

Grâce à des méthodes de synchronisation telles que les verrous mutex, les verrous en lecture-écriture, les variables de condition et les opérations atomiques, nous pouvons garantir efficacement l'exactitude et la fiabilité des programmes Golang.

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!