Apakah mekanisme penyegerakan antara fungsi golang dan goroutine?

Bahasa Go menyediakan pelbagai mekanisme penyegerakan, termasuk kunci mutex, kunci baca-tulis, pembolehubah keadaan dan WaitGroup, untuk menyelesaikan ketidakkonsistenan data atau keadaan perlumbaan yang disebabkan oleh akses serentak kepada sumber yang dikongsi. Kunci Mutex menyediakan akses eksklusif kepada sumber yang dikongsi, kunci baca-tulis menyokong berbilang bacaan serentak dan penulisan tunggal, pembolehubah keadaan digunakan untuk menyelaraskan menunggu dan pemberitahuan antara Goroutines, dan WaitGroup digunakan untuk menunggu kumpulan Goroutines selesai. Sebagai contoh, dalam kes penimbal dikongsi, mutex boleh memastikan bahawa hanya satu Goroutine mengakses penimbal pada satu masa, mengelakkan rasuah data.

Mekanisme penyegerakan fungsi dan Goroutine dalam bahasa Go

Dalam pengaturcaraan serentak, mekanisme penyegerakan adalah penting untuk memastikan akses serentak kepada sumber dikongsi tidak membawa kepada ketidakkonsistenan data atau keadaan perlumbaan. Bahasa Go menyediakan pelbagai mekanisme penyegerakan Berikut adalah mekanisme yang paling biasa digunakan untuk fungsi dan penyegerakan Goroutine:

Mutex (Mutex)

Mutex menyediakan akses eksklusif kepada sumber yang dikongsi. Apabila Goroutine memperoleh mutex, Goroutine lain akan disekat sehingga Goroutine mengeluarkan mutex.

var mu sync.Mutex

func someFunction() {
    mu.Lock()
    // 对共享资源进行操作
    mu.Unlock()
}

Kunci baca-tulis (RWMutex)

Kunci baca-tulis membenarkan berbilang Goroutine membaca sumber yang dikongsi pada masa yang sama, tetapi hanya satu Goroutine boleh menulis kepada sumber yang dikongsi pada masa yang sama.

var rwmu sync.RWMutex

func someFunction() {
    rwmu.RLock()
    // 读取共享资源
    rwmu.RUnlock()
}

func anotherFunction() {
    rwmu.Lock()
    // 写入共享资源
    rwmu.Unlock()
}

Pembolehubah keadaan (Cond)

Pembolehubah keadaan digunakan untuk menyelaraskan menunggu dan pemberitahuan antara Goroutines. Goroutine boleh menunggu pada pembolehubah syarat sehingga Goroutine lain memberitahunya.

var cond sync.Cond

func someFunction() {
    cond.L.Lock()
    // 等待条件变量被通知
    cond.Wait(&cond.L)
    // 执行被通知后的代码
    cond.L.Unlock()
}

func anotherFunction() {
    cond.L.Lock()
    // 通知正在等待条件变量的 Goroutine
    cond.Signal()
    cond.L.Unlock()
}

WaitGroup

WaitGroup digunakan untuk menunggu sekumpulan Goroutines selesai. Ia memastikan bahawa operasi tertentu tidak dilakukan sehingga semua Goroutine selesai.

var wg sync.WaitGroup

func someFunction() {
    wg.Add(1)

    // Goroutine 执行一些任务

    wg.Done()
}

func main() {
    wg.Add(5)

    for i := 0; i < 5; i++ {
        go someFunction()
    }

    // 等待所有 Goroutine 完成
    wg.Wait()

    // 主 Goroutine 执行一些操作
}

Kes praktikal

Ambil penimbal yang dikongsi sebagai contoh Berbilang Goroutine membaca dan menulis data daripada penimbal. Kami boleh menggunakan mutex untuk memastikan akses serentak kepada penimbal:

var mu sync.Mutex
type Buffer struct {
    data []int
}

func (b *Buffer) Read() []int {
    mu.Lock()
    defer mu.Unlock()

    return b.data
}

func (b *Buffer) Write(data []int) {
    mu.Lock()
    defer mu.Unlock()

    b.data = data
}

Dengan menggunakan mutex, kami memastikan hanya satu Goroutine boleh mengakses penimbal yang dikongsi pada bila-bila masa, sekali gus mengelakkan rasuah data.

Atas ialah kandungan terperinci Apakah mekanisme penyegerakan antara fungsi golang dan goroutine?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!