Bagaimanakah Saya Boleh Mengumpul Data dengan Selamat daripada Pelbagai Benang Go Sambil Mencegah Keadaan Perlumbaan?

Pengumpulan Data Selamat daripada Berbilang Benang dalam Go

Mengakses data dikongsi secara serentak merentas berbilang urutan tanpa penyegerakan yang betul boleh membawa kepada gelagat yang tidak ditentukan dalam Go. Ini amat kritikal untuk senario yang melibatkan kedua-dua operasi baca dan tulis.

Risiko Akses Serentak

Dalam kes anda, berbilang rangkaian pekerja berjalan selari, manakala urutan utama secara berkala berusaha untuk mengumpul nilai daripada pekerja ini. Jika dibiarkan, keadaan perlumbaan boleh timbul, di mana beberapa utas cuba mengakses data yang sama secara serentak, berpotensi merosakkannya.

Pilihan Penyegerakan

Untuk mengelakkan isu akses serentak, anda perlu menggunakan mekanisme penyegerakan. Satu pendekatan yang biasa digunakan ialah saluran, yang memudahkan pertukaran data selamat antara goroutine. Walau bagaimanapun, dalam kes anda, saluran mungkin bukan pilihan yang paling cekap kerana anda ingin mendapatkan semula data daripada pekerja daripada meminta mereka menghantarnya secara proaktif.

Data yang Dilindungi Mutex

Penyelesaian yang lebih sesuai melibatkan melindungi struktur data kongsi menggunakan primitif penyegerakan seperti penyegerakan.RWMutex. Kunci ini memastikan bahawa hanya satu utas boleh mengubah suai data pada satu masa sambil membenarkan berbilang utas mengaksesnya serentak untuk dibaca.

Contoh Pelaksanaan

Berikut ialah pelaksanaan yang dipermudahkan menggunakan penyegerakan.RWMutex:

type Worker struct {
    iterMu sync.RWMutex
    iter   int
}

func (w *Worker) Iter() int {
    w.iterMu.RLock()
    defer w.iterMu.RUnlock()
    return w.iter
}

func (w *Worker) setIter(n int) {
    w.iterMu.Lock()
    w.iter = n
    w.iterMu.Unlock()
}

Dalam contoh ini, kaedah Iter pekerja memperoleh kunci baca dan mengembalikan kiraan lelaran semasa. Kaedah setIter memperoleh kunci tulis, mengemas kini kiraan lelaran dan melepaskan kunci.

Sebagai alternatif, anda boleh menggunakan pakej penyegerakan/atomik untuk menyediakan operasi atom pada pembilang integer, menghapuskan keperluan untuk penguncian eksplisit:

type Worker struct {
    iter int64
}

func (w *Worker) Iter() int64 {
    return atomic.LoadInt64(&w.iter)
}

func (w *Worker) setIter(n int64) {
    atomic.StoreInt64(&w.iter, n)
}

Dengan menggunakan teknik penyegerakan yang betul, anda boleh mengumpul data dengan selamat daripada berbilang rangkaian dalam Pergi, memastikan integriti data dan mencegah keadaan perlumbaan.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Mengumpul Data dengan Selamat daripada Pelbagai Benang Go Sambil Mencegah Keadaan Perlumbaan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!