Bagaimana untuk menggunakan pemetaan serentak dalam Go?

Dengan pembangunan berterusan bahasa Go, semakin ramai pembangun telah mula menggunakannya untuk membina aplikasi konkurensi tinggi. Dalam aplikasi serentak, biasanya perlu menggunakan struktur data peta untuk menyimpan dan mengurus data. Bahasa Go menyediakan jenis Peta asli, tetapi ia tidak selamat serentak. Apabila menggunakan Map dalam persekitaran serentak, anda perlu menggunakan mekanisme seperti kunci mutex untuk perlindungan. Walau bagaimanapun, pendekatan ini akan membawa kepada kemerosotan prestasi dan tidak kondusif untuk aplikasi dalam persekitaran konkurensi tinggi. Oleh itu, artikel ini akan memperkenalkan cara menggunakan pemetaan serentak dalam Go untuk meningkatkan prestasi dan kestabilan aplikasi dalam senario konkurensi tinggi.

1. Apakah pemetaan serentak?

Pemetaan serentak ialah struktur data pemetaan khas yang boleh memastikan operasi baca dan tulis selamat dalam persekitaran serentak. Ia biasanya dilaksanakan berdasarkan jadual cincang, dan elemen dalam peta boleh diakses dan diubah suai serentak dalam berbilang coroutine. Pelaksanaan pemetaan serentak perlu memastikan keselamatan benang dan prestasi tinggi, yang penting terutamanya untuk aplikasi konkurensi tinggi.

Dalam bahasa Go, pustaka standard tidak menyediakan pelaksanaan pemetaan serentak asli. Oleh itu, kita perlu membina sendiri pemetaan serentak yang cekap dan betul. Seterusnya, kami akan memperkenalkan beberapa kaedah dan teknik biasa untuk melaksanakan pemetaan serentak:

2 Pelaksanaan pemetaan serentak

1. Gunakan penyegerakan.Peta

Dalam. pakej penyegerakan bahasa Go, jenis pemetaan serentak asli - sync.Map disediakan. Ia menyediakan satu siri kaedah untuk mengurus elemen dalam pemetaan, seperti Muat, Simpan, Padam dan Julat, yang boleh melaksanakan operasi baca dan tulis serentak dan selamat dengan mudah. Jenis pelaksanaan ini boleh memastikan keselamatan dan kecekapan benang, dan merupakan pilihan yang baik.

Walau bagaimanapun, perlu diingatkan bahawa penyegerakan.Peta tidak sesuai untuk semua keadaan Contohnya, ia tidak sesuai apabila anda perlu melintasi keseluruhan Peta atau perlu mengisih mesej Peta atau melakukan sebarang operasi yang serupa. Kerana susunan lintasan unsur-unsur dalam penyegerakan.Peta adalah rawak dan susunan susunan khusus tidak pasti. Oleh itu, apabila menggunakan sync.Map, anda perlu mempertimbangkannya berdasarkan keperluan perniagaan tertentu.

Seterusnya mari kita lihat contoh penggunaan penyegerakan.Peta:

var syncMap sync.Map

syncMap.Store("key1", "value1")
value, ok := syncMap.Load("key1")
if ok {
    fmt.Println(value)
}

syncMap.Delete("key1")

2. Pelaksanaan berdasarkan kunci mutex

Pemetaan serentak berdasarkan kunci mutex Kaedah pelaksanaannya agak mudah, dan keselamatan benang dicapai melalui penguncian. Jenis penyegerakan.Mutex disediakan dalam pakej standard bahasa Go, yang boleh memastikan keselamatan serentak melalui kunci mutex. Walau bagaimanapun, perlu diambil perhatian bahawa oleh kerana operasi mengunci dan membuka kunci mutex memakan masa, kesesakan prestasi terdedah kepada berlaku dalam senario konkurensi tinggi, menjejaskan keupayaan konkurensi sistem.

Berikut ialah kod sampel untuk melaksanakan pemetaan serentak berdasarkan kunci mutex:

type SafeMap struct {
    sync.Mutex
    data map[string]string
}

func (m *SafeMap) Load(key string) (value string, ok bool) {
    m.Lock()
    defer m.Unlock()
    value, ok = m.data[key]
    return
}

func (m *SafeMap) Store(key string, value string) {
    m.Lock()
    defer m.Unlock()
    m.data[key] = value
}

Dalam contoh ini, kami mentakrifkan jenis SafeMap, yang mengandungi Peta data dalaman dan kunci Mutex pengguna untuk mengunci Peta. Apabila melakukan operasi baca dan tulis, anda perlu mengunci mutex terlebih dahulu, kemudian melakukan operasi baca dan tulis, dan akhirnya membuka kunci mutex untuk memastikan keselamatan benang.

3. Prestasi dan langkah berjaga-jaga pemetaan serentak

1. Perbandingan prestasi

Dalam kaedah pelaksanaan pemetaan serentak di atas, kami boleh menggunakan ujian prestasi untuk membandingkan prestasi antara mereka. Berikut ialah kod sampel untuk ujian prestasi menggunakan Penanda Aras:

func BenchmarkSafeMap(b *testing.B) {
    sm := SafeMap{data: make(map[string]string)}
    for i := 0; i < b.N; i++ {
        go func() {
            sm.Store("key1", "value1")
            sm.Delete("key1")
        }()
    }
}

Perlu diingat bahawa SafeMap memerlukan operasi mengunci dan membuka kunci semasa membaca dan menulis, jadi terdapat kerugian tertentu dalam ujian prestasi. Sync.Map menggunakan beberapa algoritma keselamatan serentak yang sangat dioptimumkan, jadi kesesakan prestasi kurang berkemungkinan berlaku semasa ujian prestasi.

2. Nota

Dalam pelaksanaan pemetaan serentak, anda perlu memberi perhatian kepada perkara berikut:

• Keselamatan benang perlu dipastikan, melalui pengecualian bersama Mekanisme seperti kunci digunakan untuk pemprosesan.
• Kecekapan perlu dipastikan dan operasi yang memakan masa seperti penyalinan data harus dielakkan sebaik mungkin.
• Kebuntuan perlu dielakkan, terutamanya penjagaan perlu diambil apabila beroperasi merentasi pelbagai pemetaan.

4. Ringkasan

Dalam artikel ini, kami memperkenalkan konsep pemetaan serentak dan dua kaedah untuk melaksanakan pemetaan serentak dalam bahasa Go: berdasarkan penyegerakan.Peta dan berdasarkan mutex kunci . Pada masa yang sama, kami juga membincangkan cara memilih penyelesaian yang paling sesuai dalam amalan, serta langkah berjaga-jaga dan ujian prestasi.

Memahami konsep dan pelaksanaan pemetaan serentak adalah penting untuk membina aplikasi konkurensi tinggi. Dalam amalan, kita perlu memilih kaedah pelaksanaan pemetaan serentak yang paling sesuai berdasarkan keperluan perniagaan tertentu untuk meningkatkan prestasi dan kestabilan aplikasi dalam senario konkurensi tinggi.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan pemetaan serentak dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!