Menganalisis keatoman tugasan pembolehubah Golang

Analisis atom penugasan pembolehubah Golang

Dalam pengaturcaraan Golang, penugasan pembolehubah ialah operasi asas. Walau bagaimanapun, apabila berbilang goroutine mengakses dan mengubah suai pembolehubah yang sama pada masa yang sama, perlumbaan data dan masalah konkurensi akan wujud. Untuk menyelesaikan masalah ini, Golang menyediakan operasi atom untuk memastikan keselamatan benang pembolehubah.

Operasi atom ialah operasi yang tidak terganggu semasa pelaksanaan. Di Golang, operasi atom dilaksanakan melalui pakej penyegerakan/atom. Pakej ini menyediakan satu set fungsi operasi atom, termasuk penetapan atom, penambahan dan penolakan atom, perbandingan dan pertukaran atom, dsb. Fungsi ini boleh memastikan bahawa capaian dan pengubahsuaian pembolehubah adalah atom, iaitu, ia tidak akan diganggu oleh goroutine lain.

Biar saya berikan contoh khusus untuk menggambarkan kepentingan operasi atom. Katakan kita mempunyai kiraan pembolehubah global dengan nilai awal 0. Kemudian kita mulakan 100 goroutine, dan setiap goroutine melakukan 1000 operasi kenaikan pada kiraan. Kami menjangkakan bahawa nilai kiraan akhir hendaklah 100000.

Jika kami terus menggunakan operasi penugasan pembolehubah biasa, dalam kes konkurensi, kemungkinan besar hasil yang perlu ditambah akan ditimpa oleh goroutine lain, menyebabkan nilai kiraan akhir tidak seperti yang kami jangkakan. Berikut ialah kod sampel menggunakan operasi penugasan pembolehubah biasa:

package main

import (
    "fmt"
    "sync"
)

var count int

func increase(wg *sync.WaitGroup) {
    for i := 0; i < 1000; i++ {
        count++
    }
    wg.Done()
}

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

    for i := 0; i < 100; i++ {
        go increase(&wg)
    }

    wg.Wait()

    fmt.Println(count)
}

Dalam kod di atas, kami menggunakan penyegerakan.WaitGroup untuk menunggu semua goroutine menyelesaikan pelaksanaan dan mencetak nilai kiraan dalam fungsi utama. Walau bagaimanapun, memandangkan berbilang goroutin melakukan operasi kenaikan automatik pada kiraan pada masa yang sama, persaingan data akan berlaku. Jalankan kod di atas, anda akan mendapati bahawa keputusan setiap larian adalah berbeza, dan ia bukan 100000 yang kami jangkakan.

Untuk menyelesaikan masalah perlumbaan data, kami boleh menggunakan fungsi operasi atom yang disediakan oleh pakej atom untuk menggantikan operasi penugasan pembolehubah biasa. Berikut ialah kod sampel menggunakan operasi atom:

package main

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

var count int32

func increase(wg *sync.WaitGroup) {
    for i := 0; i < 1000; i++ {
        atomic.AddInt32(&count, 1)
    }
    wg.Done()
}

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

    for i := 0; i < 100; i++ {
        go increase(&wg)
    }

    wg.Wait()

    fmt.Println(count)
}

Dalam kod di atas, kami menggunakan fungsi atomic.AddInt32 untuk melaksanakan operasi kenaikan atom pada kiraan. Parameter pertama fungsi ini ialah penunjuk kepada kiraan pembolehubah yang ingin kita kendalikan. Menjalankan kod di atas, anda akan mendapati bahawa hasil setiap larian ialah 100000 seperti yang kami jangkakan.

Dengan membandingkan dua contoh ini, kita dapat melihat kepentingan operasi atom. Dalam pengaturcaraan serentak, terutamanya apabila berbilang goroutine mengakses dan mengubah suai pembolehubah yang sama pada masa yang sama, menggunakan operasi atom boleh memastikan keselamatan rangkaian pembolehubah dan mengelakkan persaingan data dan isu konkurensi. Oleh itu, semasa menulis program Golang, kita harus menggunakan sepenuhnya fungsi operasi atom yang disediakan oleh pakej penyegerakan/atom untuk memastikan keatoman penetapan pembolehubah.

Untuk meringkaskan, ketumpatan tugasan pembolehubah Golang dicapai melalui satu set fungsi operasi atom yang disediakan oleh pakej penyegerakan/atom. Menggunakan fungsi ini boleh memastikan bahawa akses dan pengubahsuaian boleh ubah adalah atom, mengelakkan persaingan data dan masalah konkurensi. Apabila menulis program Golang, kita harus menggunakan sepenuhnya fungsi operasi atom ini untuk memastikan keselamatan benang pembolehubah.

Atas ialah kandungan terperinci Menganalisis keatoman tugasan pembolehubah Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!