Bagaimana untuk menggunakan primitif penyegerakan untuk menghalang penyelarasan Goroutine?

Untuk mengelakkan masalah konkurensi, primitif penyegerakan boleh digunakan, termasuk: Mutex: membenarkan hanya satu Goroutine mengakses data yang dikongsi pada satu-satu masa. Semaphore: Hadkan bilangan Goroutine yang boleh mengakses data yang dikongsi secara serentak. WaitGroup: Tunggu sekumpulan Goroutine untuk menyelesaikan pelaksanaan. Pembolehubah Keadaan: Membenarkan Goroutine menunggu syarat tertentu untuk dipenuhi. Kes praktikal: Gunakan Mutex untuk mencegah konkurensi dan mencegah isu persaingan data dengan menyelaraskan akses Goroutine kepada sumber yang dikongsi.

Cara menggunakan primitif penyegerakan untuk menghalang Goroutine concurrency

Dalam bahasa Go, Goroutines ialah fungsi serentak yang berkongsi ruang memori yang sama. Ini boleh membawa kepada isu konkurensi, seperti perlumbaan data, yang berlaku apabila berbilang Goroutines mengakses pembolehubah dikongsi pada masa yang sama.

Untuk mengelakkan isu konkurensi, anda boleh menggunakan primitif penyegerakan, iaitu teknik yang digunakan untuk menyelaraskan akses kepada pembolehubah dikongsi.

Primitif penyegerakan biasa

Bahasa Go menyediakan beberapa primitif penyegerakan, termasuk:

• Mutex (mutex) : Ia membenarkan hanya satu Goroutine mengakses data yang dikongsi pada satu-satu masa.
• Semaphore: Ia mengehadkan bilangan Goroutine yang boleh mengakses data kongsi pada masa yang sama.
• WaitGroup (kumpulan tunggu): Ia digunakan untuk menunggu sekumpulan Goroutines menyelesaikan pelaksanaan.
• Pembolehubah Keadaan: Ia membolehkan Goroutine menunggu untuk syarat tertentu dipenuhi.

Kes praktikal: Gunakan Mutex untuk mengelakkan konkurensi

Mari kita gunakan kes praktikal untuk menggambarkan cara menggunakan Mutex untuk mengelakkan konkurensi. Pertimbangkan senario di mana kami mempunyai struktur Counter yang mengandungi medan count. Kami ingin mengemas kini kaunter ini secara serentak menggunakan Goroutines serentak. Counter 结构，其中包含一个 count 字段。我们希望使用并发 Goroutine 并发更新该计数器。

package main

import (
    "fmt"
    "sync"
)

// Counter represents a simple counter.
type Counter struct {
    mu     sync.Mutex
    count  int
}

// Increment increments the count by 1.
func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

// GetCount returns the current value of the count.
func (c *Counter) GetCount() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

func main() {
    // Create a new counter.
    c := &Counter{}

    // Create a group of Goroutines to increment the counter concurrently.
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            c.Increment()
        }()
    }

    // Wait for all Goroutines to finish.
    wg.Wait()

    // Print the final count.
    fmt.Println("Final count:", c.GetCount())
}

在这个案例中，Mutex 用于保护对 count 字段的访问。当一个 Goroutine 尝试更新计数器时，它会先获取 Mutexrrreee

Dalam kes ini, Mutex digunakan untuk melindungi akses kepada medan count. Apabila Goroutine cuba mengemas kini kaunter, ia mula-mula memperoleh kunci Mutex. Ini akan menghalang Goroutine lain daripada mengemas kini kaunter pada masa yang sama, sekali gus menghalang perlumbaan data.

Melaksanakan program ini mencetak kiraan akhir, iaitu jumlah semua kenaikan Goroutine. Ini menunjukkan bahawa Mutex telah berjaya menghalang isu konkurensi. 🎜

Atas ialah kandungan terperinci Bagaimana untuk menggunakan primitif penyegerakan untuk menghalang penyelarasan Goroutine?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!