Analisis atom dan perbincangan aplikasi tugasan pembolehubah Golang

Analisis atom dan aplikasi penugasan pembolehubah di Golang

Dalam pengaturcaraan serentak, keatoman pembolehubah adalah konsep yang sangat penting. Dalam persekitaran berbenang tunggal, tugasan pembolehubah dan operasi baca ialah operasi atom, iaitu, operasi ini tidak akan terganggu. Walau bagaimanapun, dalam persekitaran berbilang benang, kerana berbilang benang akan mengakses pembolehubah yang sama pada masa yang sama, jika langkah yang sesuai tidak diambil, masalah seperti persaingan data akan berlaku.

Di Golang, operasi atom boleh dilakukan dengan menggunakan pakej penyegerakan/atomik. Pakej ini menyediakan beberapa fungsi operasi atom, seperti AddInt32, AddInt64, CompareAndSwapInt32, CompareAndSwapInt64, SwapInt32, SwapInt64, dsb., yang boleh memastikan keatoman tugasan pembolehubah dan operasi baca, sekali gus menyelesaikan masalah persaingan data dalam berbilang benang dengan berkesan.

Di bawah, kami akan meneroka analisis atom dan aplikasi penugasan pembolehubah di Golang melalui contoh kod khusus.

Contoh 1: Operasi atom

Kod berikut digunakan untuk mensimulasikan operasi berbilang benang pada pembolehubah kongsi. Kami mentakrifkan kiraan pembolehubah global, dan kemudian mencipta 100 coroutine Setiap coroutine menambah 1 kepada kiraan 10,000 kali. Akhir sekali, keluarkan nilai kiraan untuk mengesahkan ketepatannya.

package main

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

var count int32
var wg sync.WaitGroup

func main() {
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go add()
    }
    wg.Wait()
    fmt.Println(count)
}

func add() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
        atomic.AddInt32(&count, 1)
    }
}

Keputusan yang dijalankan adalah seperti berikut:

1000000

Anda dapat melihat bahawa hasil output ialah 1000000. Dengan kata lain, operasi menambah 1 untuk mengira dengan 100 coroutine semuanya bersifat atom, dan tiada masalah persaingan data.

Contoh 2: Operasi bukan atom

Kod berikut juga digunakan untuk mensimulasikan operasi berbilang benang pada pembolehubah kongsi. Begitu juga, kami mentakrifkan kiraan pembolehubah global, dan kemudian mencipta 100 coroutine Setiap coroutine menambah 1 untuk mengira 10,000 kali. Tetapi kali ini kita melakukannya menggunakan penambahan biasa dan bukannya menggunakan atomic.AddInt32. Akhir sekali, keluarkan nilai kiraan untuk mengesahkan ketepatannya.

package main

import (
    "fmt"
    "sync"
)

var count int32
var wg sync.WaitGroup

func main() {
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go add()
    }
    wg.Wait()
    fmt.Println(count)
}

func add() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
        count++
    }
}

Keputusan larian adalah seperti berikut:

524999

Anda boleh lihat hasil keluaran ialah 524999, bukan 1000000 yang dijangkakan. Ini kerana dalam persekitaran berbilang benang, count++ bukanlah operasi atom dan mungkin terganggu. Jika berbilang coroutine mengubah suai kiraan pada masa yang sama, masalah persaingan data akan berlaku, mengakibatkan keputusan yang salah. Oleh itu, dalam persekitaran berbilang benang, kita perlu menggunakan operasi atom untuk memastikan pengubahsuaian pembolehubah adalah atom.

Ringkasan

Di Golang, operasi atom boleh dilakukan dengan menggunakan pakej penyegerakan/atom. Pakej ini menyediakan beberapa fungsi operasi atom untuk memastikan keatoman tugasan berubah dan operasi baca. Apabila menggunakan pengaturcaraan serentak berbilang benang, fungsi operasi atom ini boleh digunakan untuk mengelakkan masalah seperti persaingan data dan memastikan ketepatan dan kestabilan program.

Atas ialah kandungan terperinci Analisis atom dan perbincangan aplikasi tugasan pembolehubah Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!