這是“掌握 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!")
}

等等什么？沒有打印任何內容？為什么？

讓我們想象一下這一點，以了解可能發(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 維護一個內部計數(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 提供了一種安全共享數(shù)據(jù)的方法。

將通道視為管道：一個 goroutine 可以將數(shù)據(jù)發(fā)送到通道，另一個 goroutine 可以接收數(shù)據(jù)。

以下是一些屬性：

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

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é)程創(chuàng)建完成通道
啟動三個下載 goroutine
每個 goroutine 都會獲得對同一通道的引用

下載執(zhí)行:

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

頻道循環(huán):

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

循環(huán)行為:

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

完成順序并不重要！

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

兩個goroutine如何通信？

我們已經了解了兩個 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)
}

讓我們想象一下并試運行一下：

緩沖通道

為什么我們需要緩沖通道？
無緩沖的通道會阻塞發(fā)送方和接收方，直到另一方準備好為止。當需要高頻通信時，無緩沖的通道可能會成為瓶頸，因為兩個 goroutine 必須暫停來交換數(shù)據(jù)。

緩沖通道屬性：

1. FIFO（先進先出，類似于隊列）
2. 固定大小，在創(chuàng)建時設置
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ū)已經滿了“第一”和“第二”。由于沒有并發(fā)接收者來使用這些值，因此發(fā)送操作會無限期地阻塞。

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

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

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

要點

使用 緩沖 通道如果:

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

使用 無緩沖 通道，如果:

1. goroutines 之間的同步至關重要。
2. 您想要簡單并立即傳遞數(shù)據(jù)。
3. 發(fā)送者和接收者之間的交互必須即時發(fā)生。

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

下一篇文章：

1. 并發(fā)模式
2. 互斥和內存同步

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

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