Synchronisationsmechanismus zwischen Golang-Funktion und Goroutine

Der Synchronisierungsmechanismus in Go umfasst: Kanal: Wird zum sicheren Übertragen von Daten zwischen Goroutinen verwendet, indem Sende- und Empfangsvorgänge blockiert werden. Mutex-Sperre: Stellen Sie sicher, dass nur eine Goroutine gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen kann. Wartegruppe: Verfolgt die Anzahl der Goroutinen, die auf den Abschluss warten. Dieser Mechanismus ermöglicht es der Haupt-Goroutine, auf den Abschluss aller Goroutinen zu warten, bevor sie mit der Ausführung fortfährt.

Synchronisationsmechanismus von Funktionen und Goroutinen in Go

In Go sind Funktionen und Goroutinen gleichzeitige Ausführungseinheiten. Um die Koordination und Datenintegrität zwischen ihnen sicherzustellen, ist ein Synchronisierungsmechanismus erforderlich. In diesem Artikel werden die häufig verwendeten Synchronisierungsmechanismen in Go vorgestellt und praktische Beispiele vorgestellt.

Kanal

Ein Kanal ist ein Puffer, der zum sicheren Übertragen von Daten zwischen Goroutinen verwendet wird. Der Sendevorgang (ch ) und der Empfangsvorgang (<code>v := ) des Kanals blockieren beide. Das bedeutet, dass der Sender nur Daten sendet, wenn im Kanal Platz verfügbar ist, und der Empfänger nur dann Daten empfängt, wenn im Kanal Daten verfügbar sind. <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

Praktischer Fall: Verwenden von Kanälen zum Übertragen von Daten zwischen mehreren Goroutinen

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 ist ein Synchronisationsmechanismus auf niedriger Ebene, der verwendet wird, um sicherzustellen, dass nur eine Goroutine gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen kann . Der Typ sync.Mutex bietet Zugriff auf Mutex-Sperren.

🎜Praktischer Fall: Verwenden Sie Mutex-Sperren, um den Zugriff auf gemeinsam genutzte Ressourcen zu schützen🎜🎜rrreee🎜🎜WaitGroup🎜🎜🎜Die Wartegruppe wird verwendet, um die Anzahl der Goroutinen zu verfolgen, die auf den Abschluss warten. Wenn Goroutinen abgeschlossen sind, rufen sie die Methode Done auf, um die Anzahl der Wartegruppen zu verringern. Die Haupt-Goroutine kann blockieren, bis alle Goroutinen abgeschlossen sind, indem sie die Methode Wait aufruft. 🎜🎜🎜Praktischer Fall: Verwenden von Wartegruppen, um auf den Abschluss aller Goroutinen zu warten. Durch das Verständnis der Verwendung von Kanälen, Mutexes und Wartegruppen können Sie die Koordination und Datenkonsistenz zwischen Funktionen und Goroutinen sicherstellen. 🎜

Das obige ist der detaillierte Inhalt vonSynchronisationsmechanismus zwischen Golang-Funktion und Goroutine. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!