Gestion des blocages dans la programmation simultanée de la fonction Golang

Deadlock est un état de programmation simultanée dans lequel plusieurs processus ou threads s'attendent les uns les autres pour libérer des ressources, empêchant le programme de continuer. Go fournit les mécanismes suivants pour gérer les blocages : Mutex et Channel : utilisés pour garantir qu'un seul goroutine peut accéder à la ressource à la fois. Détection de blocage : le runtime Go fournit un détecteur de blocage qui panique lorsqu'un blocage est détecté. Modèles de concurrence : les modèles de concurrence fournissent un ensemble de règles pour éviter les blocages.

Gestion des blocages dans la programmation simultanée fonctionnelle Golang

Qu'est-ce qu'un blocage ?

Deadlock est un état dans un programme concurrent dans lequel deux processus ou threads ou plus s'attendent l'un l'autre pour libérer des ressources, empêchant le programme de continuer.

Gestion des blocages dans Go

Go fournit divers mécanismes pour gérer les blocages :

• Mutex et canaux : sync.Mutex et les canaux peuvent être utilisés pour garantir qu'il n'y a qu'un seul goroutine Accédez aux ressources à chaque fois.
sync.Mutex 和通道可用于确保仅一个 goroutine 每次都能访问资源。
• 死锁检测： Go 运行时提供了一个死锁检测器，它在检测到死锁时会发出 panic。
• Concurrence Patterns： 诸如 "dining philosophers" 等并发模式提供了一组规则，可以避免死锁。

实战案例

考虑以下示例，其中两个 goroutine 试图彼此发送数据：

package main

import (
    "sync"
)

func main() {
    var wg sync.WaitGroup

    ch1 := make(chan int)
    ch2 := make(chan int)

    // 发送数据到 ch1
    go func() {
        defer wg.Done()
        for {
            ch1 <- 1
            data := <-ch2
            _ = data
        }
    }()

    // 发送数据到 ch2
    go func() {
        defer wg.Done()
        for {
            ch2 <- 2
            data := <-ch1
            _ = data
        }
    }()

    wg.Add(2)
    wg.Wait()
}

由于 ch1 和 ch2

Détection de blocage : 🎜 Le runtime Go fournit un détecteur de blocage qui panique lorsqu'un blocage est détecté. 🎜🎜Modèles de concurrence : 🎜 Les modèles de concurrence tels que les « philosophes à manger » fournissent un ensemble de règles pour éviter les blocages. 🎜🎜Cas pratique🎜🎜🎜Considérons l'exemple suivant où deux goroutines tentent de s'envoyer des données : 🎜

// 使用 Mutex
package main

import (
    "sync"
)

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

    ch1 := make(chan int)
    ch2 := make(chan int)

    // 发送数据到 ch1
    go func() {
        defer wg.Done()
        for {
            m.Lock()
            ch1 <- 1
            data := <-ch2
            _ = data
            m.Unlock()
        }
    }()

    // 发送数据到 ch2
    go func() {
        defer wg.Done()
        for {
            m.Lock()
            ch2 <- 2
            data := <-ch1
            _ = data
            m.Unlock()
        }
    }()

    wg.Add(2)
    wg.Wait()
}

🎜Puisque ch1 et ch2< /code> En attente de réception de données, donc un blocage se produira. Pour résoudre ce problème, vous pouvez utiliser Mutex ou des canaux pour vous assurer qu'une seule goroutine peut accéder à la ressource à la fois : 🎜

// 使用通道
package main

func main() {
    var wg sync.WaitGroup

    ch1 := make(chan int)
    ch2 := make(chan int)

    // 发送数据到 ch1
    go func() {
        defer wg.Done()
        for {
            select {
            case ch1 <- 1:
                data := <-ch2
                _ = data
            }
        }
    }()

    // 发送数据到 ch2
    go func() {
        defer wg.Done()
        for {
            select {
            case ch2 <- 2:
                data := <-ch1
                _ = data
            }
        }
    }()

    wg.Add(2)
    wg.Wait()
}

rrreee

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!