Pergi pengaturcaraan serentak: penggunaan saluran dan penyegerakan primitif

Ringkasnya, saluran dan primitif penyegerakan dalam Go ialah alat penting dalam pengaturcaraan serentak. Saluran digunakan untuk menukar data dengan selamat, manakala primitif penyegerakan digunakan untuk mengawal pelaksanaan serentak Goroutines. Khususnya, saluran membenarkan Goroutines menghantar data, mutex melindungi sumber yang dikongsi, pembolehubah syarat menunggu keadaan menjadi benar dan peristiwa digunakan untuk menyegerakkan Goroutines. Dengan menggunakan mekanisme ini, pembangun boleh mencipta aplikasi serentak yang cekap dan berskala.

Go Pengaturcaraan Serentak: Penggunaan Saluran dan Primitif Penyegerakan

Saluran dan primitif penyegerakan dalam Go ialah alatan utama untuk melaksanakan pengaturcaraan serentak. Artikel ini akan meneroka penggunaan kedua-dua mekanisme dan menunjukkan kuasanya melalui contoh praktikal.

Saluran

Saluran ialah mekanisme yang digunakan untuk menukar data dengan selamat antara Goroutines serentak. Ia serupa dengan paip, data boleh ditulis dari satu hujung dan dibaca dari hujung yang lain.

// 声明一个用于传递整数的通道
channel := make(chan int)

// 在一个 Goroutine 中写入通道
go func() {
    channel <- 42
}()

// 在另一个 Goroutine 中读取通道
value := <-channel

Primitif penyegerakan

Primitif penyegerakan ialah satu siri alatan untuk mengawal pelaksanaan Goroutine serentak. Ia termasuk perkara seperti kunci, mutex, pembolehubah keadaan dan peristiwa.

Mutex lock

Mutex lock digunakan untuk memastikan hanya satu Goroutine mengakses sumber kongsi pada masa yang sama.

// 声明一个互斥锁
var mu sync.Mutex

// 在一个 Goroutine 中使用互斥锁保护共享资源
func incrementCounter() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

Pembolehubah bersyarat

Pembolehubah bersyarat digunakan untuk menunggu keadaan tertentu menjadi benar. Goroutine boleh menunggu pembolehubah keadaan sehingga syarat dipenuhi sebelum meneruskan pelaksanaan.

// 声明一个条件变量
var cv sync.Cond

// 在一个 Goroutine 中等待条件
func waitForCondition() {
    cv.L.Lock()
    for !condition {
        cv.Wait()
    }
    cv.L.Unlock()
}

// 在另一个 Goroutine 中唤醒等待条件的 Goroutine
func signalCondition() {
    cv.L.Lock()
    condition = true
    cv.Broadcast()
    cv.L.Unlock()
}

Kes praktikal

Menggunakan saluran untuk memproses tugasan secara selari

Masalah konkurensi biasa ialah pemprosesan tugasan selari. Masalah ini boleh diselesaikan dengan mencipta satu set Goroutines yang mengira keputusan dan meletakkan hasilnya ke dalam saluran.

// 生成任务列表
tasks := []func() int{
    func() int { return 1 },
    func() int { return 2 },
    func() int { return 3 },
}

// 创建一个通道来接收结果
results := make(chan int)

// 创建 Goroutine 来计算任务
for _, task := range tasks {
    go func(task func() int) {
        results <- task()
    }(task)
}

// 从通道中接收结果
for i := 0; i < len(tasks); i++ {
    result := <-results
    fmt.Println(result)
}

Gunakan kunci mutex untuk melindungi keadaan kongsi

Satu lagi masalah konkurensi biasa ialah melindungi keadaan kongsi. Masalah ini boleh diselesaikan dengan menggunakan mutex untuk memastikan hanya satu Goroutine mengakses keadaan kongsi pada masa yang sama.

Atas ialah kandungan terperinci Pergi pengaturcaraan serentak: penggunaan saluran dan penyegerakan primitif. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!