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)

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