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

// 使用 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()
}

// 使用通道
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()
}