Deadlock handling in Golang function concurrent programming

Deadlock is a state in concurrent programming in which multiple processes or threads wait for each other to release resources, causing the program to be unable to continue. Go provides the following mechanisms to deal with deadlocks: Mutex and Channel: used to ensure that only one goroutine can access the resource at a time. Deadlock detection: The Go runtime provides a deadlock detector that will panic when a deadlock is detected. Concurrence Patterns: Concurrency patterns provide a set of rules to avoid deadlocks.

Deadlock handling in Golang function concurrent programming

What is a deadlock?

Deadlock is a state in a concurrent program in which two or more processes or threads are waiting for each other to release resources, causing the program to be unable to continue.

Handling deadlocks in Go

Go provides various mechanisms to handle deadlocks:

• Mutex and channels : sync.Mutex and channels can be used to ensure that only one goroutine can access the resource at a time.
• Deadlock detection: The Go runtime provides a deadlock detector that will panic when a deadlock is detected.
• Concurrence Patterns: Concurrency patterns such as "dining philosophers" provide a set of rules to avoid deadlocks.

Practical Case

Consider the following example where two goroutines are trying to send data to each other:

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()
}

Due toch1 and ch2 are both waiting to receive data, so a deadlock will occur. To solve this problem, you can use Mutex or channels to ensure that only one goroutine can access the resource at a time:

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

The above is the detailed content of Deadlock handling in Golang function concurrent programming. For more information, please follow other related articles on the PHP Chinese website!