L'art de résoudre les impasses avec les fonctions Golang

Golang fournit les fonctions suivantes pour résoudre le problème de blocage : sync.Mutex : verrouillage Mutex, garantissant qu'un seul thread peut accéder aux ressources protégées en même temps. sync.RWMutex : verrouillage en lecture-écriture, qui permet à plusieurs threads de lire des ressources en même temps, mais n'autorise qu'un seul thread à écrire des ressources.

Fonction Golang : L'art de résoudre les impasses

Le problème de l'impasse est souvent rencontré dans la programmation simultanée, c'est-à-dire que deux ou plusieurs processus ou threads se font concurrence pour les ressources, ce qui amène le programme à atteindre une impasse. Golang fournit certaines fonctions pour aider à résoudre les problèmes de blocage, et cet article présentera les fonctions les plus couramment utilisées.

sync.Mutex

sync.Mutex est un verrou mutex, qui garantit qu'un seul thread peut accéder aux ressources protégées en même temps. La syntaxe d'utilisation de sync.Mutex est la suivante : sync.Mutex 是一个互斥锁，它保证同一时间只有一个线程可以访问受保护的资源。使用 sync.Mutex 的语法如下：

import "sync"

var mu sync.Mutex

func main() {
    mu.Lock()
    // 访问受保护的资源
    mu.Unlock()
}

在上面的例子中，Lock() 方法会阻塞线程，直到该锁被解锁。Unlock() 方法会释放锁，允许其他线程访问受保护的资源。

sync.RWMutex

sync.RWMutex 是一个读写锁，它允许多个线程同时读取资源，但只允许一个线程写入资源。使用 sync.RWMutex 的语法如下：

import "sync"

var rwmu sync.RWMutex

func main() {
    rwmu.RLock()
    // 读取受保护的资源
    rwmu.RUnlock()

    rwmu.Lock()
    // 写入受保护的资源
    rwmu.Unlock()
}

在上面的例子中，RLock() 方法允许多个线程同时读取资源，而 Lock() 方法会阻塞线程，直到该锁被解锁。

Deadlock Example

下面是一个死锁的示例：

import "sync"

var mu1 sync.Mutex
var mu2 sync.Mutex

func f1() {
    mu1.Lock()
    mu2.Lock()
    // ...
}

func f2() {
    mu2.Lock()
    mu1.Lock()
    // ...
}

在这个例子中，函数 f1() 和 f2() 都会尝试争用两个互斥锁，最终导致死锁。

防止死锁

为了防止死锁，可以使用以下技巧：

• 避免两个线程尝试以相反的顺序争用锁。
• 只争用必要的锁。
• 使用计时器或超时机制来检测和打破死锁。
• 使用 sync.Once 来确保代码只执行一次。

实战案例

在一个并发 Web 应用程序中，我们可以使用 sync.Mutex 来保护对数据库的访问：

import (
    "database/sql"
    "sync"
)

var db *sql.DB
var dbLock sync.Mutex

func init() {
    db, _ = sql.Open("mysql", "root:password@localhost:3306/test")
}

func GetUserData(userID int) (*User, error) {
    dbLock.Lock()
    defer dbLock.Unlock()

    // 从数据库中查询用户数据
}

通过使用 sync.Mutexrrreee

Dans l'exemple ci-dessus, la méthode Lock() bloque le thread jusqu'à ce que le verrou soit déverrouillé. La méthode Unlock() libère le verrou, permettant à d'autres threads d'accéder à la ressource protégée. 🎜🎜sync.RWMutex🎜🎜sync.RWMutex est un verrou en lecture-écriture qui permet à plusieurs threads de lire des ressources en même temps, mais n'autorise qu'un seul thread à écrire des ressources. La syntaxe d'utilisation de sync.RWMutex est la suivante : 🎜rrreee🎜Dans l'exemple ci-dessus, la méthode RLock() permet à plusieurs threads de lire les ressources simultanément, tandis que le Lock( ) bloque le thread jusqu'à ce que le verrou soit déverrouillé. 🎜🎜Exemple de blocage🎜🎜Ce qui suit est un exemple de blocage : 🎜rrreee🎜Dans cet exemple, les fonctions f1() et f2() tenteront toutes deux de rivaliser pour deux verrous Mutex, conduisant finalement à une impasse. 🎜🎜Prévenir les blocages🎜🎜Pour éviter les blocages, vous pouvez utiliser les techniques suivantes : 🎜

• Évitez que deux threads tentent de se disputer le verrou dans l'ordre opposé.
• Concourez uniquement pour les verrous nécessaires.
• Utilisez des minuteries ou des délais d'attente pour détecter et résoudre les blocages.
• Utilisez sync.Once pour vous assurer que le code n'est exécuté qu'une seule fois.

🎜Cas pratique🎜🎜Dans une application web concurrente, on peut utiliser sync.Mutex pour protéger l'accès à la base de données : 🎜rrreee🎜En utilisant sync .Mutex , nous pouvons garantir qu'un seul thread peut accéder à la connexion à la base de données en même temps, évitant ainsi des problèmes tels que l'incohérence des données qui peuvent survenir lors de l'accès simultané à la base de données. 🎜

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!