Verrous et mutex intégrés en langage Go

Verrous et mutex intégrés dans le langage Go

Avec la popularité des processeurs multicœurs, la programmation multithread est devenue un élément indispensable du développement d'applications. Dans la programmation multithread, les verrous constituent un mécanisme important utilisé pour contrôler l'accès simultané aux ressources partagées. Le langage Go offre une multitude de mécanismes de verrouillage, dont les plus couramment utilisés sont les verrous et mutex intégrés.

Apportez votre propre cadenas

Bring your own lock est un mécanisme de verrouillage en langage Go, léger, facile à utiliser et performant. Le verrou intégré est une variable avec des conditions de concurrence. Autrement dit, lors de l'accès simultané aux ressources partagées, si plusieurs threads accèdent à la variable en même temps, une condition de concurrence se produira. Dans ce cas, une synchronisation est requise pour éviter des résultats incohérents.

Dans le langage Go, les opérations de synchronisation peuvent être facilement effectuées à l'aide du verrou intégré. Le verrou intégré a deux méthodes importantes, Lock() et Unlock(). La méthode Lock() est utilisée pour acquérir le verrou. Si le verrou est déjà occupé par d'autres threads, le thread appelant entrera dans un état de blocage et attendra. pour que le verrou soit libéré ; la méthode Unlock() est utilisée pour libérer le verrou.

Exemple d'utilisation du verrou intégré :

var mu sync.Mutex  // 定义一个锁变量
var count int

func main() {
    for i := 0; i < 1000; i++ {
        go add()  // 启动1000个线程，对count进行加1操作
    }
    time.Sleep(time.Second)  // 等待所有线程执行完成
    fmt.Println(count)  // 打印最终结果
}

func add() {
    mu.Lock()  // 获取锁
    count++  // 对共享变量进行操作
    mu.Unlock()  // 释放锁
}

Dans le code ci-dessus, un nombre de variables globales est utilisé comme ressource partagée, et il est incrémenté de 1 en démarrant 1000 threads. Afin de garantir que l'accès simultané à la variable count ne provoquera pas de conditions de concurrence, un verrou intégré est utilisé pour la synchronisation. Dans la fonction add(), appelez d'abord la méthode mu.Lock() pour acquérir le verrou, exploitez la ressource partagée, puis libérez le verrou via la méthode mu.Unlock(). Cela garantit que l’opération sur la variable count est atomique et évite les conditions de concurrence.

Mutex

Mutex est un autre mécanisme de verrouillage du langage Go, qui est également utilisé pour protéger les ressources partagées. Les mutex sont similaires aux verrous intégrés et peuvent être utilisés pour éviter les conditions de concurrence, mais en comparaison, les mutex peuvent verrouiller et déverrouiller des opérations sur des blocs de code plus fins.

L'utilisation du mutex est similaire à son propre verrou. Dans le langage Go, le type de mutex est sync.Mutex, et le prototype est le suivant :

type Mutex struct {
    // 包含Mutex的内部结构
}

func (m *Mutex) Lock() {
    // 加锁操作
}

func (m *Mutex) Unlock() {
    // 解锁操作
}

Lorsque vous utilisez un mutex, vous devez également ajouter des blocs de code qui doivent être synchronisés entre Lock() et Unlock() méthodes pour assurer le partage de l’exactitude des ressources.

Exemple d'utilisation d'un mutex :

var mu sync.Mutex  // 定义一个互斥量
var count int

func main() {
    for i := 0; i < 1000; i++ {
        go add()  // 启动1000个线程，对count进行加1操作
    }
    time.Sleep(time.Second)  // 等待所有线程执行完成
    fmt.Println(count)  // 打印最终结果
}

func add() {
    mu.Lock()  // 获取锁
    count++  // 对共享变量进行操作
    mu.Unlock()  // 释放锁
}

Semblable à l'utilisation de verrous intégrés, un mutex est utilisé dans le code ci-dessus pour synchroniser l'accès au nombre de ressources partagées.

Résumé

Les verrous et mutex intégrés sont des mécanismes de synchronisation courants dans le langage Go, utilisés pour protéger les ressources partagées contre les modifications simultanées. Le verrou intégré convient aux opérations de verrouillage et de déverrouillage sur l'ensemble du bloc de code, tandis que le mutex peut être utilisé pour les opérations de verrouillage et de déverrouillage sur des blocs de code plus fins. Dans le développement réel, le mécanisme de verrouillage approprié doit être sélectionné en fonction des besoins spécifiques afin de garantir la fiabilité et la concurrence du programme.

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!