penggantian atom golang

Golang ialah bahasa pengaturcaraan yang dibangunkan oleh Google Ia mempunyai fungsi yang sangat berkuasa dalam pengaturcaraan serentak. Salah satu daripadanya ialah operasi atom, yang memastikan ketepatan sumber yang dikongsi dalam persekitaran berbilang benang. Di Golang, operasi atom disediakan oleh pakej penyegerakan/atom Artikel ini akan memperkenalkan operasi penggantian atom secara terperinci.

Sebelum memperkenalkan penggantian atom, mari kita fahami dahulu apa itu operasi atom. Dalam pengaturcaraan berbilang benang, jika berbilang benang perlu mengakses sumber yang dikongsi pada masa yang sama, beberapa masalah akan berlaku jika akses tidak diselaraskan. Contohnya, jika berbilang rangkaian cuba mengubah suai nilai yang sama pada masa yang sama, keadaan perlumbaan mungkin berlaku, menyebabkan ralat program atau tingkah laku yang tidak dapat diramalkan.

Untuk menyelesaikan masalah ini, kita boleh menggunakan teknik yang dipanggil operasi atom. Operasi atom ialah operasi tidak boleh dibahagikan yang tidak boleh diganggu atau diubah suai semasa pelaksanaan. Ini mengelakkan keadaan perlumbaan yang disebabkan oleh berbilang urutan mengakses sumber yang dikongsi pada masa yang sama. Golang menyediakan beberapa fungsi operasi atom, seperti AddInt32, AddInt64, CompareAndSwapInt32, dll.

Fungsi operasi penggantian atom ialah SwapInt32, SwapInt64, SwapUint32, SwapUint64 dan SwapPointer. Mengambil SwapInt32 sebagai contoh, prototaip fungsinya adalah seperti berikut:

func SwapInt32(addr *int32, int32 baharu) (int32 lama)

Fungsi ini menerima penunjuk kepada pembolehubah jenis int32 dan nilai Int32 baharu, ia akan cuba menggantikan nilai pada alamat memori yang ditunjuk oleh penuding dengan nilai baharu dan mengembalikan nilai asal. Jika penggantian gagal disebabkan pengubahsuaian serentak, nilai asal dikembalikan. Fungsi ini adalah atom, walaupun berbilang benang memanggil SwapInt32 pada masa yang sama untuk mengubah suai nilai yang sama, tidak akan ada masalah.

Mari kita lihat contoh mudah. Kaunter dalam contoh ialah pembolehubah jenis int32, dan berbilang benang akan cuba meningkatkan nilainya sebanyak 1 pada masa yang sama. Jika anda tidak menggunakan operasi penggantian atom, anda perlu menggunakan kunci untuk memastikan berbilang benang tidak mengubah suai pembilang pada masa yang sama, yang akan menyebabkan kemerosotan prestasi. Dengan operasi penggantian atom, tidak perlu menggunakan kunci. Kodnya adalah seperti berikut:

package main

import (
    "fmt"
    "sync/atomic"
    "time"
)

func main() {
    var counter int32
    
    for i := 1; i <= 10; i++ {
        go func() {
            for {
                oldValue := atomic.LoadInt32(&counter)
                if atomic.CompareAndSwapInt32(&counter, oldValue, oldValue+1) {
                    break
                }
                time.Sleep(time.Millisecond)
            }
        }()
    }
    
    time.Sleep(time.Second * 1)
    
    fmt.Println(counter)
}

Dalam contoh ini, kami menetapkan nilai awal pembilang kepada 0 dan memulakan 10 goroutine untuk menambah 1 padanya. Dalam setiap goroutine, kami menggunakan gelung for untuk terus mencuba menambah nilai pembilang sebanyak 1. Fungsi LoadInt32 digunakan di sini untuk membaca nilai pembilang, dan fungsi CompareAndSwapInt32 digunakan untuk melaksanakan operasi penggantian atom. Di sini oldValue digunakan sebagai nilai asas untuk perbandingan Jika nilai pembilang semasa adalah sama dengan oldValue, operasi penggantian atom dilakukan. Jika penggantian berjaya, keluar dari gelung jika penggantian gagal, tunggu sebentar dan cuba lagi.

Dalam contoh ini, keadaan perlumbaan yang mungkin ialah berbilang goroutin membaca nilai pembilang sebagai k pada masa yang sama, dan kemudian meningkatkannya sebanyak 1 pada masa yang sama, menyebabkan pembilang hanya meningkat sebanyak 1. Walau bagaimanapun, disebabkan oleh penggunaan operasi penggantian atom, setiap goroutine hanya akan beroperasi apabila ia cuba mengubah suai pembilang tidak boleh mengubah suai pembilang, jadi tiada keadaan perlumbaan akan berlaku. Output nilai pembilang akhir oleh program hendaklah 10, dan hasilnya secara amnya seperti ini.

Artikel ini memperkenalkan fungsi operasi penggantian atom dalam Golang, termasuk SwapInt32, SwapInt64, SwapUint32, SwapUint64 dan SwapPointer. Operasi atom ialah cara penting untuk memastikan ketepatan sumber yang dikongsi dalam pengaturcaraan berbilang benang, dan ia boleh mengelakkan keadaan perlumbaan. Golang menyediakan beberapa fungsi operasi atom untuk melaksanakan fungsi seperti kunci putaran dan operasi CAS Pengaturcara boleh memilih fungsi operasi atom yang sesuai untuk menyelesaikan masalah dalam pengaturcaraan serentak.

Atas ialah kandungan terperinci penggantian atom golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!