Tetapan penyegerakan Golang

Golang ialah bahasa pengaturcaraan yang berkuasa dan kelebihannya dalam mengendalikan pengaturcaraan serentak juga diiktiraf secara meluas. Di Golang, tetapan penyegerakan adalah bahagian penting dalam mengendalikan pengaturcaraan serentak, dan ia juga merupakan salah satu kunci untuk memastikan ketepatan program. Oleh itu, dalam artikel ini, kami akan menyelidiki persediaan penyegerakan Golang dan membincangkan cara ia membolehkan kawalan serentak yang cekap.

Tetapan penyegerakan Golang

Tetapan penyegerakan Golang terutamanya termasuk aspek berikut:

1. Mutex (Mutex)

Mutex ialah salah satu daripada tetapan penyegerakan yang paling biasa digunakan. Ia memastikan bahawa hanya satu utas mengakses sumber yang dikongsi pada masa yang sama. Dalam Go, kunci mutex boleh dilaksanakan menggunakan jenis Mutex yang disediakan oleh pakej penyegerakan.

Anda perlu memberi perhatian kepada perkara berikut apabila menggunakan Mutex:

• Anda perlu memperoleh kunci sebelum mengakses sumber kongsi dan anda perlu melepaskan kunci selepas digunakan.
• Pastikan untuk tidak memanggil penyekatan atau operasi yang memakan masa lama semasa mengunci, jika tidak, benang lain tidak akan dapat memperoleh kunci.

2. Kunci baca-tulis (RWMutex)

RWMutex ialah kunci yang menyokong berbilang operasi baca dan satu operasi tulis pada masa yang sama. Dalam Go, RWMutex boleh dilaksanakan menggunakan jenis RWMutex yang disediakan oleh pakej penyegerakan.

Anda perlu memberi perhatian kepada perkara berikut apabila menggunakan RWMutex:

• Anda perlu mendapatkan kunci baca atau kunci tulis sebelum mengakses sumber kongsi dan anda perlu melepaskan kunci selepas digunakan.
• Kunci tulis dan kunci baca adalah saling eksklusif, iaitu, semasa satu utas memperoleh kunci tulis, utas lain tidak boleh memperoleh kunci baca atau kunci tulis pada masa yang sama.

3. Pembolehubah keadaan (Cond)

Cond ialah mekanisme penyegerakan berasaskan kunci yang digunakan untuk menyegerakkan perubahan dalam keadaan sumber dikongsi antara utas. Dalam Go, anda boleh menggunakan jenis Cond yang disediakan oleh pakej penyegerakan untuk melaksanakan pembolehubah keadaan.

Anda perlu memberi perhatian kepada perkara berikut apabila menggunakan pembolehubah keadaan:

• Anda perlu mendapatkan kunci yang berkaitan sebelum mengakses sumber yang dikongsi dan anda perlu melepaskan kunci selepas guna.
• Apabila menunggu pembolehubah keadaan, anda perlu memastikan keadaan memenuhi syarat supaya sumber yang dikongsi boleh digunakan dengan betul apabila bangun dari tidur.

4. Semaphore

Semaphore ialah tetapan penyegerakan klasik, yang juga boleh dilaksanakan di Golang dengan menggunakan saluran. Sebagai contoh, anda boleh menentukan saluran dengan penimbal untuk melaksanakan fungsi kaunter untuk mengawal akses serentak.

Anda perlu memberi perhatian kepada perkara berikut apabila menggunakan semaphore:

• Anda perlu mendapatkan semaphore sebelum mengakses sumber yang dikongsi, dan anda perlu melepaskan semaphore selepas akses itu selesai.
• Anda boleh menggunakan saluran dengan penimbal untuk melaksanakan fungsi kaunter untuk mengawal akses serentak dengan berkesan.

Contoh aplikasi tetapan penyegerakan Golang

Untuk lebih memahami tetapan penyegerakan Golang, mari kita lihat contoh mudah untuk menunjukkan cara menggunakan kunci mutex.

Pertama, kita perlu mencipta struktur yang mengandungi sumber kongsi:

type SharedResource struct {
    count int
    mutex sync.Mutex
}

Struktur ini mengandungi kiraan pembilang dan mutex mutex untuk melindungi pembilang.

Seterusnya, kita boleh mencipta dua utas untuk melaksanakan operasi baca dan tulis melalui mutex kunci mutex:

func (s *SharedResource) Increment() {
    s.mutex.Lock()
    defer s.mutex.Unlock()
    s.count++
}

func (s *SharedResource) Decrement() {
    s.mutex.Lock()
    defer s.mutex.Unlock()
    s.count--
}

Dalam kaedah Penambahan dan Penurunan, kita perlu mendapatkan kunci mutex dan mengira pembilang Operasi baca dan tulis dilakukan, dan kemudian kunci dilepaskan.

Akhir sekali, kami boleh mencipta berbilang rangkaian untuk menggunakan sumber yang dikongsi:

func main() {
    var wg sync.WaitGroup
    sharedResource := SharedResource{}
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            sharedResource.Increment()
            sharedResource.Decrement()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println(sharedResource.count)
}

Dalam contoh ini, kami mencipta 10 rangkaian untuk menggunakan sumber yang dikongsi secara serentak. Dalam setiap urutan, kami mula-mula memanggil kaedah Penambahan untuk meningkatkan kiraan sebanyak 1, dan kemudian memanggil kaedah Penurunan untuk mengurangkan kiraan sebanyak 1. Akhir sekali, kami menunggu semua benang selesai melaksanakan dan kemudian mengeluarkan nilai kiraan.

Melalui contoh ini, kita dapat melihat cara menggunakan kunci mutex dan cara memastikan ketepatan sumber yang dikongsi.

Ringkasan

Tetapan penyegerakan Golang merupakan bahagian penting dalam mencapai pengaturcaraan serentak yang cekap, antaranya kunci mutex, kunci baca-tulis, pembolehubah keadaan dan semaphore adalah cara utama untuk mencapai penyegerakan. Dalam proses menggunakan tetapan penyegerakan, kita perlu memberi perhatian kepada pemerolehan dan pelepasan kunci, penggunaan pembolehubah keadaan yang betul, dll., untuk memastikan ketepatan sumber yang dikongsi. Dengan mendalami penggunaan tetapan penyegerakan, kami boleh membangunkan atur cara serentak yang cekap dengan lebih baik.

Atas ialah kandungan terperinci Tetapan penyegerakan Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!