1。運行每個範例：不要只閱讀程式碼。輸入它，運行它，然後觀察其行為。 ⚠️ 這個系列如何進行？
2。實驗和打破常規： 刪除睡眠並看看會發生什麼，更改通道緩衝區大小，修改 goroutine 計數。
打破東西會教你它們是如何運作的
3。關於行為的原因： 在執行修改後的程式碼之前，嘗試預測結果。當您看到意外行為時，請停下來思考原因。挑戰解釋。
4。建立心理模型：每個視覺化代表一個概念。嘗試為修改後的程式碼繪製自己的圖表。 
這是「掌握 Go 並發」系列的 第 1 部分，我們將介紹：
我們將從基礎知識開始，逐步發展如何有效使用它們的直覺。
這會有點長，相當長，所以做好準備。
我們將親力親為完成整個過程。
讓我們從一個下載多個檔案的簡單程式開始。
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例程：
注意：函數呼叫前使用 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!")
}
等等什麼？沒有列印任何內容？為什麼？
讓我們想像一下這一點，以了解可能發生的情況。
從上面的視覺化中，我們了解到 main 函數在 goroutine 完成之前就存在了。一項觀察結果是，所有 goroutine 的生命週期都依賴 main 函數。
注意：main函數本身就是一個goroutine;)
為了解決這個問題，我們需要一種方法讓主 goroutine 等待其他 goroutine 完成。有幾種方法可以做到這一點：
讓我們等待幾秒鐘讓 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 可能需要多長時間。在這種情況下，我們每個人都有固定的時間，但在實際場景中，我們知道下載時間會有所不同。
Go中的sync.WaitGroup是一種並發控制機制，用於等待一組goroutines執行完成。
在這裡讓我們看看它的實際效果並視覺化：
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 的工作原理：
計數器機制：
同步流程：
要避免的常見陷阱
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 例程如何通訊？這就是頻道發揮作用的地方。
Go 中的Channels 是一個強大的並發原語，用於 goroutine 之間的通信。它們為 goroutine 提供了一種安全共享資料的方法。
將通道視為管道：一個 goroutine 可以將資料傳送到通道，另一個 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 發送，因此主Goroutine 在發送到通道時不會被阻塞，因此它會移動到msg :=
現在讓我們使用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)
}
可視化它：
讓我們進行一次演練以更好地理解：
節目開始：
主協程建立完成通道
啟動三個下載 goroutine
每個 goroutine 都會獲得對同一通道的引用
下載執行:
頻道循環:
循環行為:
完成順序並不重要！
觀察：
⭐ 每次發送（完成 ⭐ 主協程透過循環協調一切
我們已經了解了兩個 goroutine 如何進行溝通。什麼時候？一直以來。 我們不要忘記 main 函數也是一個 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)
}
讓我們想像一下並試運行一下：
試運轉：
程式開始（t=0ms）
第一則訊息（t=1ms）
第二則訊息（t=101ms）
第三則訊息（t=201ms）
通道關閉（t=301ms）
完成（t=302-303ms）
為什麼我們需要緩衝通道？
無緩衝的通道會阻塞傳送方和接收方，直到另一方準備好為止。當需要高頻通訊時，無緩衝的通道可能會成為瓶頸，因為兩個 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
為什麼它沒有阻塞主協程？
緩衝通道允許發送至其容量而不阻塞發送者。
通道的容量為 2，這表示它在阻塞之前可以在緩衝區中保存兩個值。
緩衝區已經滿了「第一」和「第二」。由於沒有並發接收者來使用這些值，因此發送操作會無限期地阻塞。
因為主 goroutine 也負責發送，並且沒有其他活動的 goroutine 從通道接收值，所以程式在嘗試發送第三條訊息時陷入死鎖。
取消註解第三則訊息會導致死鎖，因為容量現在已滿，第三則訊息將阻塞，直到緩衝區釋放。
| Aspect | Buffered Channels | Unbuffered Channels |
|---|---|---|
| Purpose | For decoupling sender and receiver timing. | For immediate synchronization between sender and receiver. |
| When to Use | - When the sender can proceed without waiting for receiver. | - When sender and receiver must synchronize directly. |
| - When buffering improves performance or throughput. | - When you want to enforce message-handling immediately. | |
| Blocking Behavior | Blocks only when buffer is full. | Sender blocks until receiver is ready, and vice versa. |
| Performance | Can improve performance by reducing synchronization. | May introduce latency due to synchronization. |
| Example Use Cases | - Logging with rate-limited processing. | - Simple signaling between goroutines. |
| - Batch processing where messages are queued temporarily. | - Hand-off of data without delay or buffering. | |
| Complexity | Requires careful buffer size tuning to avoid overflows. | Simpler to use; no tuning needed. |
| Overhead | Higher memory usage due to the buffer. | Lower memory usage; no buffer involved. |
| Concurrency Pattern | Asynchronous communication between sender and receiver. | Synchronous communication; tight coupling. |
| Error-Prone Scenarios | Deadlocks if buffer size is mismanaged. | Deadlocks if no goroutine is ready to receive or send. |
使用 緩衝 通道如果:
使用 無緩衝 通道，如果:
這些基礎知識為更高階的概念奠定了基礎。在我們即將發布的帖子中，我們將探討：
下一篇：
請繼續關注我們，我們將繼續加深對 Go 強大並發功能的理解！
以上是透過直覺的視覺效果了解 Golang 中的 Goroutines 和 Channel的詳細內容。更多資訊請關注PHP中文網其他相關文章！
