Analyse de document en langage Go : la fonction sync.Mutex implémente le verrouillage mutex

Le langage Go est un langage de programmation open source qui utilise un modèle de programmation concurrente pour gérer l'exécution alternée de plusieurs tâches. Dans la programmation simultanée, cela implique souvent plusieurs coroutines ou threads accédant aux ressources partagées en même temps. Dans ce cas, un verrou mutex doit être utilisé pour garantir l'exclusivité de la ressource et éviter l'apparition de conditions de concurrence.

Dans le langage Go, le package sync est fourni pour implémenter diverses primitives de synchronisation, y compris les verrous mutex. Le type sync.Mutex est le type de verrouillage mutex le plus basique. Il implémente un accès mutuellement exclusif aux ressources via deux méthodes : Lock et Unlock. sync包来实现各种同步原语，其中就包括互斥锁。sync.Mutex类型是最基本的互斥锁类型，它通过两个方法Lock和Unlock来实现资源的互斥访问。

下面我们来具体看一下sync.Mutex的使用。

package main

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

var count int
var mutex sync.Mutex

func increment() {
    mutex.Lock() // 加锁
    defer mutex.Unlock() // 解锁，在函数执行完毕后自动调用
    count++
}

func main() {
    for i := 0; i < 10; i++ {
        go increment()
    }

    time.Sleep(time.Second) // 等待所有协程执行完毕

    fmt.Println("count:", count)
}

在上面的代码中，首先定义了一个全局变量count用来记录计数器的值，然后定义了一个sync.Mutex类型的互斥锁mutex。在increment函数中，通过调用mutex.Lock()来获得互斥锁，保证只有一个协程能够进入临界区执行count++操作，然后调用mutex.Unlock()来释放互斥锁，让其他协程可以继续竞争执行。

在main函数中，通过循环创建了10个协程，每个协程都调用increment函数来增加计数器的值。为了保证所有协程都执行完毕，我们使用time.Sleep函数来让主协程等待1秒钟。

最后，我们将计数器的值打印出来，可以看到正确输出了count: 10。

使用互斥锁可以保证共享资源的安全访问，避免了数据竞态的发生。在多个协程或线程访问共享资源时，使用互斥锁是非常重要的。Go语言的sync.Mutex

Examinons de plus près l'utilisation de sync.Mutex. 🎜rrreee🎜Dans le code ci-dessus, une variable globale count est d'abord définie pour enregistrer la valeur du compteur, puis un verrou mutex de type sync.Mutex est définimutex. Dans la fonction increment, obtenez le verrou mutex en appelant mutex.Lock() pour vous assurer qu'une seule coroutine peut entrer dans la section critique pour exécuter count++, puis appelez mutex.Unlock() pour libérer le verrou mutex afin que les autres coroutines puissent continuer à rivaliser pour l'exécution. 🎜🎜Dans la fonction main, 10 coroutines sont créées via une boucle, et chaque coroutine appelle la fonction increment pour incrémenter la valeur du compteur. Afin de garantir que toutes les coroutines sont exécutées, nous utilisons la fonction time.Sleep pour faire attendre la coroutine principale pendant 1 seconde. 🎜🎜Enfin, nous imprimons la valeur du compteur, et vous pouvez voir que count: 10 est correctement affiché. 🎜🎜L'utilisation de verrous mutex peut garantir un accès sécurisé aux ressources partagées et éviter les conditions de course aux données. Il est très important d'utiliser des verrous mutex lorsque plusieurs coroutines ou threads accèdent à des ressources partagées. sync.Mutex du langage Go fournit une fonction de verrouillage mutex simple et puissante, rendant la programmation simultanée plus facile et plus sûre. 🎜

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!