Rumah > pembangunan bahagian belakang > Golang > Isu keselamatan ingatan dalam pengaturcaraan serentak fungsi Golang

Isu keselamatan ingatan dalam pengaturcaraan serentak fungsi Golang

WBOY
Lepaskan: 2024-04-17 15:12:02
asal
880 orang telah melayarinya

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

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++
}
Salin selepas log masuk

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)
    }
}
Salin selepas log masuk

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)
}
Salin selepas log masuk

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

var count int
var mu sync.Mutex

func incrementCount() {
    mu.Lock()
    defer mu.Unlock()
    count++
}
Salin selepas log masuk

使用互斥锁,countrrreee

Jika tiada penyegerakan ditambahkan, pengiraan akhir Nilai Ia mungkin kurang daripada 100000, dan mungkin berbeza-beza apabila bilangan goroutine bertambah. Ini boleh dicegah dengan menggunakan mutex: 🎜rrreee🎜Dengan mutex, nilai akhir count sentiasa 100000 dan tidak dipengaruhi oleh bilangan goroutin. 🎜

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!

sumber:php.cn
Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan