Mengapakah nilai pembolehubah dalam program Go saya tidak segerak merentas urutan yang berbeza?

Dalam bahasa Go, menggunakan coroutine untuk melaksanakan operasi serentak telah menjadi cara yang sangat popular. Walau bagaimanapun, apabila pembolehubah dikongsi antara berbilang coroutine, masalah perlumbaan data boleh berlaku dengan mudah. Perlumbaan data ialah pepijat pengaturcaraan serentak yang berlaku apabila dua atau lebih utas cuba membaca atau menulis lokasi memori yang sama pada masa yang sama. Dalam kes ini, program mungkin menghasilkan keputusan yang tidak dapat diramalkan dan salah.

Dalam bahasa Go, untuk mengelakkan situasi ini, anda boleh menggunakan mekanisme seperti kunci mutex untuk menyelesaikannya.

Penggunaan kunci mutex

Kunci Mutex ialah kunci yang digunakan dalam bahasa Go untuk akses segerak kepada sumber yang dikongsi. Apabila coroutine perlu mengakses sumber yang dikongsi, ia perlu mendapatkan mutex terlebih dahulu dan kemudian melaksanakan operasi. Selepas operasi selesai, kunci mutex perlu dilepaskan supaya coroutine lain boleh terus mengakses sumber yang dikongsi.

Kunci mutex digunakan seperti berikut:

import "sync"

var mu sync.Mutex // 互斥锁

func main() {
    // ...

    mu.Lock() // 获取互斥锁
    // 访问共享资源
    mu.Unlock() // 释放互斥锁

    // ...
}

Dalam kod di atas, kaedah Lock() digunakan untuk memperoleh kunci mutex, dan kaedah Unlock() digunakan untuk melepaskan kunci mutex. Apabila coroutine memperoleh kunci mutex, coroutine lain mesti menunggu untuk melepaskan kunci mutex sebelum mereka boleh memperoleh kunci mutex. Ini mengelakkan masalah perlumbaan data.

Contoh

Berikut ialah contoh yang menunjukkan cara menggunakan kunci mutex untuk menyelesaikan masalah perlumbaan data.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    count := 0
    mu := sync.Mutex{}

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            mu.Lock()
            count++
            mu.Unlock()
            wg.Done()
        }()
    }

    wg.Wait()
    fmt.Println("count: ", count)
}

Dalam kod di atas, kami mula-mula mentakrifkan objek WaitGroup untuk merekodkan bilangan coroutine. Kemudian tentukan mutex mu dan pembilang count. Kemudian mulakan 100 coroutine, dan setiap coroutine menambah satu pembilang. Memandangkan kaunter count ialah sumber yang dikongsi, adalah perlu untuk mendapatkan kunci mutex sebelum operasi dan melepaskan kunci mutex selepas operasi selesai. Akhir sekali, gunakan kaedah Wait() untuk menunggu semua coroutine tamat dan mencetak nilai pembilang.

Keputusan operasi adalah seperti berikut:

count:  100

Berdasarkan keputusan, operasi itu berjaya. Pada ketika ini nilai pembolehubah disegerakkan dalam benang yang berbeza.

Ringkasan

Apabila menggunakan coroutine untuk operasi serentak dalam bahasa Go, berbilang coroutine boleh mengakses sumber kongsi yang sama, jadi anda perlu memberi perhatian kepada isu persaingan data. Kunci Mutex ialah sejenis kunci yang digunakan untuk menyelesaikan persaingan data, yang boleh mengelakkan masalah berbilang coroutine yang mengakses sumber kongsi yang sama pada masa yang sama dengan berkesan. Dengan menggunakan kunci mutex, nilai pembolehubah boleh dijamin untuk disegerakkan dalam benang yang berbeza.

Atas ialah kandungan terperinci Mengapakah nilai pembolehubah dalam program Go saya tidak segerak merentas urutan yang berbeza?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!