Pengendalian kebuntuan dalam fungsi Golang pengaturcaraan serentak

Kebuntuan ialah keadaan dalam pengaturcaraan serentak di mana berbilang proses atau utas menunggu antara satu sama lain untuk melepaskan sumber, menyebabkan program tidak dapat diteruskan. Go menyediakan mekanisme berikut untuk menangani kebuntuan: Mutex dan Saluran: digunakan untuk memastikan hanya satu goroutine boleh mengakses sumber pada satu masa. Pengesanan jalan buntu: Waktu jalanan Go menyediakan pengesan jalan buntu yang akan panik apabila jalan buntu dikesan. Corak Konkurensi: Corak Konkurensi menyediakan satu set peraturan untuk mengelakkan kebuntuan.

Pengendalian kebuntuan dalam pengaturcaraan serentak berfungsi Golang

Apakah kebuntuan?

Kebuntuan ialah keadaan dalam program serentak di mana dua atau lebih proses atau utas sedang menunggu antara satu sama lain untuk melepaskan sumber, menyebabkan program tidak dapat diteruskan.

Mengendalikan kebuntuan dalam Go

Go menyediakan pelbagai mekanisme untuk menangani kebuntuan:

• Mutex dan saluran: sync.Mutex dan saluran boleh digunakan untuk memastikan hanya terdapat satu goroutine Akses sumber setiap masa.
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

Pengesanan jalan buntu: 🎜 Masa jalanan Go menyediakan pengesan jalan buntu yang akan panik apabila jalan buntu dikesan. 🎜🎜Corak Konkurensi: 🎜 Corak Konkurensi seperti "ahli falsafah makan" menyediakan satu set peraturan untuk mengelakkan kebuntuan. 🎜🎜Kes Praktikal🎜🎜🎜Pertimbangkan contoh berikut di mana dua goroutin cuba menghantar data antara satu sama lain: 🎜

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

🎜Memandangkan kedua-dua ch1 dan ch2< /code> Menunggu untuk menerima data, jadi kebuntuan akan berlaku. Untuk menyelesaikan masalah ini, anda boleh menggunakan Mutex atau saluran untuk memastikan bahawa hanya satu goroutine boleh mengakses sumber pada satu masa: 🎜

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

Atas ialah kandungan terperinci Pengendalian kebuntuan dalam fungsi Golang pengaturcaraan serentak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!