Isu keselamatan ingatan dalam pengaturcaraan serentak fungsi Golang

Fungsi pengaturcaraan serentak dalam Go mempunyai isu keselamatan memori Penyelesaian termasuk: kunci mutex: menghalang berbilang goroutin daripada mengakses data yang dikongsi pada masa yang sama dan melindungi bahagian kritikal melalui operasi mengunci dan membuka kunci. Saluran: digunakan untuk memindahkan nilai dengan selamat antara goroutine untuk memastikan susunan nilai. Kumpulan menunggu segerak: Menyelaras pelaksanaan serentak berbilang goroutin untuk memastikan program utama diteruskan hanya selepas semua goroutin selesai.

Isu keselamatan ingatan dalam pengaturcaraan serentak fungsi Golang

Dalam pengaturcaraan serentak, adalah penting untuk memastikan keselamatan ingatan. Dalam Go, goroutine ialah primitif serentak ringan yang menimbulkan cabaran unik untuk keselamatan ingatan.

Apabila berbilang goroutine mengakses memori yang dikongsi secara serentak, perlumbaan data mungkin berlaku, mengakibatkan data tidak konsisten atau rosak. Kunci untuk menyelesaikan masalah ini ialah menggunakan mekanisme penyegerakan yang betul, seperti mutex dan saluran.

Mutex lock

Mutex lock ialah mekanisme penyegerakan yang membenarkan hanya satu goroutine mengakses data kongsi dalam bahagian kritikal pada satu masa. Prinsip asas adalah untuk melindungi bahagian kritikal melalui operasi mengunci dan membuka kunci.

var mu sync.Mutex

func incrementValue(ptr *int) {
    mu.Lock()
    defer mu.Unlock()
    *ptr++
}

Saluran

Saluran ialah alat asas untuk melaksanakan konkurensi dalam Go, yang membolehkan nilai dihantar dengan selamat antara goroutin. Saluran itu sendiri adalah berurutan, bermakna nilai hanya boleh diterima mengikut susunan yang dihantar.

ch := make(chan int)

go func() {
    for i := 0; i < 10; i++ {
        ch <- i
    }
}

func main() {
    for i := 0; i < 10; i++ {
        fmt.Println(<-ch)
    }
}

Kes praktikal

Pertimbangkan contoh berikut, di mana dua goroutine mengubah suai pembolehubah kongsi kira pada masa yang sama: count：

var count int

func incrementCount() {
    count++
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        for i := 0; i < 50000; i++ {
            incrementCount()
        }
        wg.Done()
    }()

    go func() {
        for i := 0; i < 50000; i++ {
            incrementCount()
        }
        wg.Done()
    }()

    wg.Wait()
    fmt.Println(count)
}

如果不加同步，则最终的 count 值可能会小于 100000，并且可能随着 goroutine 数的增加而有极大的差异。通过使用互斥锁，可以防止这种情况发生：

var count int
var mu sync.Mutex

func incrementCount() {
    mu.Lock()
    defer mu.Unlock()
    count++
}

使用互斥锁，countrrreee

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