這是「掌握 Go 並發(fā)」系列的 第 1 部分，我們將介紹：

• goroutine 的工作原理及其生命週期
• goroutines 之間的通道通訊
• 緩衝通道及其用例
• 實際範例與視覺化

我們將從基礎知識開始，逐步發(fā)展如何有效使用它們的直覺。

這會有點長，相當長，所以做好準備。

我們將親力親為完成整個過程。

Goroutine 的基礎

讓我們從一個下載多個檔案的簡單程式開始。

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

程式總共需要 6 秒，因為每個 2 秒的下載必須在下一個開始之前完成。讓我們想像一下：

我們可以縮短這個時間，讓我們修改我們的程式以使用go例程：

注意：函數(shù)呼叫前使用 go 關鍵字

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    // Launch downloads concurrently
    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    fmt.Println("All downloads completed!")
}

等等什麼？沒有列印任何內(nèi)容？為什麼？

讓我們想像一下這一點，以了解可能發(fā)生的情況。

從上面的視覺化中，我們了解到 main 函數(shù)在 goroutine 完成之前就存在了。一項觀察結果是，所有 goroutine 的生命週期都依賴 main 函數(shù)。

注意：main函數(shù)本身就是一個goroutine;)

為了解決這個問題，我們需要一種方法讓主 goroutine 等待其他 goroutine 完成。有幾種方法可以做到這一點：

1. 等待幾秒鐘（駭客方式）
2. 使用 WaitGroup（正確的方法，下一步）
3. 使用頻道（我們將在下面介紹）

讓我們等待幾秒鐘讓 go 程式完成。

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

問題是，我們可能不知道 goroutine 可能需要多長時間。在這種情況下，我們每個人都有固定的時間，但在實際場景中，我們知道下載時間會有所不同。

來了sync.WaitGroup

Go中的sync.WaitGroup是一種並發(fā)控制機制，用於等待一組goroutines執(zhí)行完成。

在這裡讓我們看看它的實際效果並視覺化：

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    // Launch downloads concurrently
    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    fmt.Println("All downloads completed!")
}

讓我們可視化這一點並了解sync.WaitGroup 的工作原理：

計數(shù)器機制：

• WaitGroup 維護一個內(nèi)部計數(shù)器
• wg.Add(n) 將計數(shù)器增加 n
• wg.Done() 將計數(shù)器減 1
• wg.Wait() 阻塞，直到計數(shù)器達到 0

同步流程：

• 主 Goroutine 在啟動 Goroutines 之前呼叫 Add(3)
• 每個 goroutine 完成時都會呼叫 Done()
• 主協(xié)程在 Wait() 處被阻塞，直到計數(shù)器達到 0
• 當計數(shù)器達到 0 時，程式繼續(xù)並乾淨地退出

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now() // Record start time

    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

頻道

這樣我們就很好地理解了 goroutine 是如何運作的。不，兩個 Go 例程如何通訊？這就是頻道發(fā)揮作用的地方。

Go 中的

Channels 是一個強大的並發(fā)原語，用於 goroutine 之間的通信。它們?yōu)?goroutine 提供了一種安全共享資料的方法。

將通道視為管道：一個 goroutine 可以將資料傳送到通道，另一個 goroutine 可以接收資料。

以下是一些屬性：

1. 通道本質(zhì)上是阻塞的。
2. A 送到通道操作 ch 阻塞直到其他 Goroutine 從通道接收。
3. 從通道接收操作阻塞直到其他goroutine送到通道。

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

為什麼 ch

讓我們透過加入 goroutine 來解決這個問題

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    // Launch downloads concurrently
    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    fmt.Println("All downloads completed!")
}

讓我們想像一下：

這次訊息從不同的Goroutine 發(fā)送，因此主Goroutine 在發(fā)送到通道時不會被阻塞，因此它會移動到msg :=

使用通道修復 main 不等其他問題

現(xiàn)在讓我們使用channel來修復文件下載器問題（main不等待其他人完成）。

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now() // Record start time

    go downloadFile("file1.txt")
    go downloadFile("file2.txt")
    go downloadFile("file3.txt")

    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

可視化它：

讓我們進行一次演練以更好地理解：

節(jié)目開始：

主協(xié)程建立完成通道
啟動三個下載 goroutine
每個 goroutine 都會獲得對同一通道的引用

下載執(zhí)行:

1. 所有三個下載同時運行
2. 每個需要2秒
3. 他們可能會以任何順序完成

頻道循環(huán):

1. 主協(xié)程進入迴圈： for i := 0;我
2. 每個
3. 循環(huán)確保我們等待所有三個完成訊號

循環(huán)行為:

1. 迭代 1：阻塞至首次下載完成
2. 迭代 2：阻塞直到第二次下載完成
3. 迭代 3：阻塞至最終下載完成

完成順序並不重要！

觀察：
? 每次發(fā)送（完成 ? 主協(xié)程透過循環(huán)協(xié)調(diào)一切

兩個goroutine如何通信？

我們已經(jīng)了解了兩個 goroutine 如何進行溝通。什麼時候？一直以來。 我們不要忘記 main 函數(shù)也是一個 goroutine。

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

讓我們想像一下並試運行一下：

緩衝通道

為什麼我們需要緩衝通道？
無緩衝的通道會阻塞傳送方和接收方，直到另一方準備好為止。當需要高頻通訊時，無緩衝的通道可能會成為瓶頸，因為兩個 goroutine 必須暫停來交換資料。

緩衝通道屬性：

1. FIFO（先進先出，類似隊列）
2. 固定大小，建立時設定
3. 緩衝區(qū)已滿時阻止發(fā)送者
4. 當緩衝區(qū)為空時阻塞接收器

我們看到它的實際效果：

package main

import (
    "fmt"
    "time"
)

func downloadFile(filename string) {
    fmt.Printf("Starting download: %s\n", filename)
    // Simulate file download with sleep
    time.Sleep(2 * time.Second)
    fmt.Printf("Finished download: %s\n", filename)
}

func main() {
    fmt.Println("Starting downloads...")

    startTime := time.Now()

    downloadFile("file1.txt")
    downloadFile("file2.txt")
    downloadFile("file3.txt")

    elapsedTime := time.Since(startTime)

    fmt.Printf("All downloads completed! Time elapsed: %s\n", elapsedTime)
}

輸出（在取消註解 ch

為什麼它沒有阻塞主協(xié)程？

1. 緩衝通道允許發(fā)送至其容量而不阻塞發(fā)送者。

2. 通道的容量為 2，這表示它在阻塞之前可以在緩衝區(qū)中保存兩個值。

3. 緩衝區(qū)已經(jīng)滿了「第一」和「第二」。由於沒有並發(fā)接收者來使用這些值，因此發(fā)送操作會無限期地阻塞。

4. 因為主 goroutine 也負責發(fā)送，並且沒有其他活動的 goroutine 從通道接收值，所以程式在嘗試發(fā)送第三條訊息時陷入死鎖。

取消註解第三則訊息會導致死鎖，因為容量現(xiàn)在已滿，第三則訊息將阻塞，直到緩衝區(qū)釋放。

何時使用緩衝通道與非緩衝通道

重點

使用 緩衝 通道如果:

1. 你需要解耦發(fā)送者和接收者的時間。
2. 批次或排隊訊息可以提高效能。
3. 當緩衝區(qū)已滿時，應用程式可以容忍處理訊息的延遲。

使用 無緩衝 通道，如果:

1. goroutines 之間的同步至關重要。
2. 您想要簡單並立即傳遞資料。
3. 傳送者和接收者之間的互動必須即時發(fā)生。

這些基礎知識為更高階的概念奠定了基礎。在我們即將發(fā)布的帖子中，我們將探討：

下一篇：

1. 並發(fā)模式
2. 互斥與記憶體同步

請繼續(xù)關注我們，我們將繼續(xù)加深對 Go 強大並發(fā)功能的理解！

以上是透過直覺的視覺效果了解 Golang 中的 Goroutines 和 Channel的詳細內(nèi)容。更多資訊請關注PHP中文網(wǎng)其他相關文章！