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

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

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

這會(huì)有點(diǎn)長，相當(dāng)長，所以做好準(zhǔn)備。

我們將親力親為完成整個(gè)過程。

Goroutine 的基礎(chǔ)

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

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 秒，因?yàn)槊總€(gè) 2 秒的下載必須在下一個(gè)開始之前完成。讓我們想像一下：

我們可以縮短這個(gè)時(shí)間，讓我們修改我們的程式以使用go例程：

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

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)容？為什麼？

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

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

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

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

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 可能需要多長時(shí)間。在這種情況下，我們每個(gè)人都有固定的時(shí)間，但在實(shí)際場(chǎng)景中，我們知道下載時(shí)間會(huì)有所不同。

來了sync.WaitGroup

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

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

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!")
}

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

計(jì)數(shù)器機(jī)制：

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

同步流程：

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

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 是如何運(yùn)作的。不，兩個(gè) Go 例程如何通訊？這就是頻道發(fā)揮作用的地方。

Go 中的

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

將通道視為管道：一個(gè) goroutine 可以將資料傳送到通道，另一個(gè) 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 來解決這個(gè)問題

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ā)送到通道時(shí)不會(huì)被阻塞，因此它會(huì)移動(dòng)到msg :=

使用通道修復(fù) main 不等其他問題

現(xiàn)在讓我們使用channel來修復(fù)文件下載器問題（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)
}

可視化它：

讓我們進(jìn)行一次演練以更好地理解：

節(jié)目開始：

主協(xié)程建立完成通道
啟動(dòng)三個(gè)下載 goroutine
每個(gè) goroutine 都會(huì)獲得對(duì)同一通道的引用

下載執(zhí)行:

1. 所有三個(gè)下載同時(shí)運(yùn)行
2. 每個(gè)需要2秒
3. 他們可能會(huì)以任何順序完成

頻道循環(huán):

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

循環(huán)行為:

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

完成順序並不重要！

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

兩個(gè)goroutine如何通信？

我們已經(jīng)了解了兩個(gè) goroutine 如何進(jìn)行溝通。什麼時(shí)候？一直以來。 我們不要忘記 main 函數(shù)也是一個(gè) 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)
}

讓我們想像一下並試運(yùn)行一下：

緩衝通道

為什麼我們需要緩衝通道？
無緩衝的通道會(huì)阻塞傳送方和接收方，直到另一方準(zhǔn)備好為止。當(dāng)需要高頻通訊時(shí)，無緩衝的通道可能會(huì)成為瓶頸，因?yàn)閮蓚€(gè) goroutine 必須暫停來交換資料。

緩衝通道屬性：

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

我們看到它的實(shí)際效果：

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ū)中保存兩個(gè)值。

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

4. 因?yàn)橹?goroutine 也負(fù)責(zé)發(fā)送，並且沒有其他活動(dòng)的 goroutine 從通道接收值，所以程式在嘗試發(fā)送第三條訊息時(shí)陷入死鎖。

取消註解第三則訊息會(huì)導(dǎo)致死鎖，因?yàn)槿萘楷F(xiàn)在已滿，第三則訊息將阻塞，直到緩衝區(qū)釋放。

何時(shí)使用緩衝通道與非緩衝通道

重點(diǎn)

使用 緩衝 通道如果:

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

使用 無緩衝 通道，如果:

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

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

下一篇：

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

請(qǐng)繼續(xù)關(guān)注我們，我們將繼續(xù)加深對(duì) Go 強(qiáng)大並發(fā)功能的理解！

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