Mekanisme penyegerakan antara fungsi golang dan goroutine

Mekanisme penyegerakan dalam Go termasuk: Saluran: digunakan untuk memindahkan data dengan selamat antara Goroutines, menggunakan operasi penyekatan hantar dan terima. Kunci Mutex: Pastikan hanya satu Goroutine boleh mengakses sumber yang dikongsi pada masa yang sama. Kumpulan menunggu: Menjejaki bilangan Goroutine yang menunggu untuk diselesaikan Mekanisme ini membenarkan Goroutine utama menunggu semua Goroutine selesai sebelum meneruskan pelaksanaan.

Mekanisme penyegerakan antara fungsi dan Goroutine dalam Go

In Go, fungsi dan Goroutines ialah unit pelaksanaan serentak. Untuk memastikan penyelarasan dan integriti data antara mereka, mekanisme penyegerakan diperlukan. Artikel ini akan memperkenalkan mekanisme penyegerakan yang biasa digunakan dalam Go dan menyediakan kes praktikal.

Saluran

Saluran ialah penimbal yang digunakan untuk memindahkan data dengan selamat antara Goroutines. Operasi penghantaran saluran (ch ) dan operasi terima (<code>v := ) kedua-duanya menyekat. Ini bermakna bahawa pengirim hanya akan menghantar data jika terdapat ruang yang tersedia dalam saluran, dan penerima hanya akan menerima data jika terdapat data yang tersedia dalam saluran. <code>ch ）和接收操作（<code>v := ）都是阻塞的。这意味着发送方只有在通道中有可用的空间时才会发送数据，而接收方只有在通道中有可用数据时才会接收数据。

实战案例：使用通道在多个 Goroutine 之间传递数据

package main

import "fmt"

func main() {
    // 创建一个带有缓冲区的通道（可以存储最多 10 个值）
    ch := make(chan int, 10)

    // 启动 5 个 Goroutine 向通道发送数据
    for i := 0; i < 5; i++ {
        go func(i int) {
            ch <- i
        }(i)
    }

    // 从通道接收数据并打印结果
    for i := 0; i < 5; i++ {
        fmt.Println(<-ch)
    }
}

互斥锁 (Mutex)

互斥锁是一种低级的同步机制，用于确保同一时间只有一个 Goroutine 可以访问共享资源。sync.Mutex 类型提供了对互斥锁的访问。

实战案例：使用互斥锁保护对共享资源的访问

package main

import (
    "fmt"
    "sync"
)

var (
    mu      sync.Mutex // 定义一个互斥锁
    counter int       // 共享资源
)

func main() {
    for i := 0; i < 100; i++ {
        go func(i int) {
            // 获取互斥锁
            mu.Lock()
            defer mu.Unlock() // 释放互斥锁

            // 访问共享资源
            counter++
            fmt.Printf("Goroutine %d: counter = %d\n", i, counter)
        }(i)
    }
}

等待组 (WaitGroup)

等待组用于跟踪正在等待完成的 Goroutine 的数量。当 Goroutine 完成时，它们调用 Done 方法来减少等待组计数。主 Goroutine可以通过调用 Wait

Kes praktikal: Menggunakan saluran untuk memindahkan data antara berbilang Goroutines

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    // 启动 5 个 Goroutine
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Printf("Goroutine %d started\n", i)
            defer wg.Done() // Goroutine 完成时调用 Done
        }(i)
    }

    // 等待所有 Goroutine 完成
    wg.Wait()
    fmt.Println("All Goroutines finished")
}

Mutex (Mutex)

Mutex ialah mekanisme penyegerakan peringkat rendah yang digunakan untuk memastikan hanya satu Goroutine boleh memproses pada masa yang sama Mengakses sumber yang dikongsi . Jenis sync.Mutex menyediakan akses kepada kunci mutex.

🎜Kes praktikal: Gunakan kunci mutex untuk melindungi akses kepada sumber yang dikongsi🎜🎜rrreee🎜🎜WaitGroup🎜🎜🎜Kumpulan tunggu digunakan untuk menjejaki bilangan Goroutine yang menunggu untuk diselesaikan. Apabila Goroutines selesai, mereka memanggil kaedah Selesai untuk mengurangkan kiraan kumpulan menunggu. Goroutine utama boleh menyekat sehingga semua Goroutine selesai dengan memanggil kaedah Tunggu. 🎜🎜🎜Kes praktikal: Menggunakan kumpulan tunggu untuk menunggu semua Goroutine selesai🎜🎜rrreee🎜🎜Memahami mekanisme penyegerakan adalah penting🎜🎜🎜Memilih mekanisme penyegerakan yang betul dalam persekitaran Goron yang mantap dan betul adalah penting untuk membina program yang mantap dan serentak. Dengan memahami penggunaan saluran, mutex dan kumpulan tunggu, anda boleh memastikan penyelarasan dan ketekalan data antara fungsi dan Goroutines. 🎜

Atas ialah kandungan terperinci Mekanisme penyegerakan antara fungsi golang dan goroutine. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!