Deadlock-Behandlung in der gleichzeitigen Programmierung von Golang-Funktionen

Deadlock ist ein Zustand bei der gleichzeitigen Programmierung, in dem mehrere Prozesse oder Threads darauf warten, dass der andere Ressourcen freigibt, was dazu führt, dass das Programm nicht fortgesetzt werden kann. Go bietet die folgenden Mechanismen zum Umgang mit Deadlocks: Mutex und Channel: Wird verwendet, um sicherzustellen, dass jeweils nur eine Goroutine auf die Ressource zugreifen kann. Deadlock-Erkennung: Die Go-Laufzeit bietet einen Deadlock-Detektor, der in Panik versetzt, wenn ein Deadlock erkannt wird. Parallelitätsmuster: Parallelitätsmuster stellen eine Reihe von Regeln bereit, um Deadlocks zu vermeiden.

Deadlock-Behandlung in der funktionalen gleichzeitigen Golang-Programmierung

Was ist ein Deadlock?

Deadlock ist ein Zustand in einem gleichzeitigen Programm, in dem zwei oder mehr Prozesse oder Threads darauf warten, dass einander Ressourcen freigibt, was dazu führt, dass das Programm nicht fortgesetzt werden kann.

Handhabung von Deadlocks in Go

Go bietet verschiedene Mechanismen zur Behandlung von Deadlocks:

• Mutex und Kanäle: sync.Mutex und Kanäle können verwendet werden, um sicherzustellen, dass es nur eine Goroutine gibt Greifen Sie jederzeit auf Ressourcen zu.
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

Deadlock-Erkennung: 🎜 Die Go-Laufzeit bietet einen Deadlock-Detektor, der in Panik gerät, wenn ein Deadlock erkannt wird. 🎜🎜Parallelitätsmuster: 🎜 Parallelitätsmuster wie „Dining Philosophers“ bieten eine Reihe von Regeln, um Deadlocks zu vermeiden. 🎜🎜Praktischer Fall🎜🎜🎜Betrachten Sie das folgende Beispiel, in dem zwei Goroutinen versuchen, einander Daten zu senden: 🎜

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

🎜Da sowohl ch1 als auch ch2< sind /code> Wartet auf den Empfang von Daten, sodass ein Deadlock auftritt. Um dieses Problem zu lösen, können Sie Mutex oder Kanäle verwenden, um sicherzustellen, dass jeweils nur eine Goroutine auf die Ressource zugreifen kann: 🎜

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

Das obige ist der detaillierte Inhalt vonDeadlock-Behandlung in der gleichzeitigen Programmierung von Golang-Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!