Pengoptimuman prestasi fungsi Go: penjelasan mendalam tentang kunci dan primitif penyegerakan

Pengoptimuman prestasi fungsi Go bergantung pada penggunaan kunci dan primitif penyegerakan yang betul. Jenis kunci: 1. Kunci Mutex (Mutex): menjamin akses eksklusif kepada sumber yang dikongsi 2. Kunci baca-tulis (RWMutex): membenarkan bacaan serentak tetapi hanya membenarkan satu penulisan. Primitif penyegerakan: 1. Pembolehubah keadaan (Cond): jeda goroutine sehingga syarat dipenuhi; 2. Operasi atom (atom): selamat membaca dan menulis pembolehubah yang dikongsi; Kes praktikal: Pengiraan serentak jumlah kepingan boleh dicapai dengan melindungi jumlah pembolehubah yang dikongsi dengan kunci mutex untuk mengelakkan masalah bukan atom yang disebabkan oleh kemas kini serentak dan meningkatkan prestasi dengan ketara.

Pengoptimuman prestasi fungsi Go: penerangan mendalam tentang kunci dan primitif penyegerakan

Dalam senario konkurensi tinggi, ciri konkurensi bahasa Go memainkan peranan penting. Memahami penggunaan kunci dan primitif penyegerakan adalah penting untuk meningkatkan prestasi fungsi Go. Artikel ini akan memberikan penjelasan yang mendalam tentang kunci dan primitif penyegerakan serta menunjukkan cara mengoptimumkan prestasi fungsi Go melalui kes praktikal.

Jenis kunci

Bahasa Go menyediakan berbilang jenis kunci, termasuk:

• Mutex (Mutex): Memastikan hanya satu goroutine boleh mengakses sumber dikongsi pada satu masa.
• Kunci baca-tulis (RWMutex): Membenarkan berbilang goroutin membaca sumber yang dikongsi pada masa yang sama, tetapi hanya membenarkan satu goroutine untuk menulis sumber.

Primitif penyegerakan

Selain kunci, bahasa Go juga menyediakan primitif penyegerakan berikut:

• Pembolehubah keadaan (Cond): digunakan untuk menjeda goroutine sehingga syarat tertentu dipenuhi.
• Operasi atom (atom): Digunakan untuk membaca dan menulis pembolehubah kongsi dengan selamat.
• WaitGroup: Digunakan untuk menunggu beberapa goroutine untuk menyelesaikan tugasan. . Kita boleh menggunakan mutex untuk memastikan kemas kini kepada sum adalah atom.

var nums = []int{1, 2, 3, 4, 5}

// 使用互斥锁保护共享变量
var mu sync.Mutex
var sum int

// 求和函数
func sumNums() {
    mu.Lock()
    defer mu.Unlock()
    for _, num := range nums {
        sum += num
    }
}

// 并发求和
func main() {
    // 创建一个 goroutine 数组
    var goroutines []*goroutine
    for i := 0; i < 4; i++ {
        goroutines[i] = goroutine.New(sumNums)
    }

    // 启动 goroutine 并等待完成
    for _, g := range goroutines {
        g.Start()
        g.Wait()
    }

    // 打印计算结果
    fmt.Println(sum)
}

Dengan menggunakan kunci mutex, berbilang goroutin boleh mengemas kini sum secara serentak sambil memastikan atomicity kemas kini. Ini meningkatkan prestasi penjumlahan dengan ketara.

Nota

Minakkan penggunaan kunci kerana kunci akan menyebabkan tambahan overhed.

Lebih suka menggunakan kunci baca-tulis untuk membolehkan kedua-dua operasi baca dan tulis. nums，需要并发地计算切片中所有元素的总和。我们可以使用互斥锁来确保对 sum 的更新是原子的。

rrreee

通过使用互斥锁，多个 goroutine 可以并发的对 sum 进行更新，同时保证更新的原子性。这显著提高了求和性能。

注意事项

• 尽量减少锁的使用，因为锁会导致额外的开销。
• 优先使用读写锁来同时允许读取和写入操作。
• 使用同步原语时，一定要调用 defer Unlock()
Apabila menggunakan primitif penyegerakan, pastikan anda memanggil tunda Buka Kunci() untuk membuka kunci.
• Elakkan memegang kunci dalam gorouti terlalu lama, yang boleh menyebabkan kebuntuan.

🎜

Atas ialah kandungan terperinci Pengoptimuman prestasi fungsi Go: penjelasan mendalam tentang kunci dan primitif penyegerakan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!