これは、「Mastering Go Concurrency」 シリーズの パート 1 であり、次の內(nèi)容について説明します。

• ゴルーチンの仕組みとそのライフサイクル
• ゴルーチン間のチャネル通信
• バッファリングされたチャネルとその使用例
• 実踐的な例と視覚化

基本から始めて、それらを効果的に使用する方法についての直観を徐々に養(yǎng)っていきます。

少し長くなり、むしろ非常に長くなりますので、準備を整えてください。

私たちはプロセス全體を通して実踐的にサポートします。

ゴルーチンの基礎(chǔ)

複數(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)
}

次のダウンロードが開始される前に 2 秒間のダウンロードが完了する必要があるため、プログラムには合計 6 秒かかります。これを視覚化してみましょう:

この時間を短くすることができます。go ルーチンを使用するようにプログラムを変更しましょう:

注意: 関數(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!")
}

待って何?何も印刷されませんでしたか？なぜ?

何が起こっているのかを理解するために、これを視覚化してみましょう。

上記の視覚化から、ゴルーチンが終了する前に main 関數(shù)が存在することがわかります。観察の 1 つは、すべての goroutine のライフサイクルが main 関數(shù)に依存しているということです。

注: main 関數(shù)自體は goroutine です ;)

これを修正するには、他のゴルーチンが完了するまでメインのゴルーチンを待機させる方法が必要です。これを行うにはいくつかの方法があります:

1. 數(shù)秒待ちます (裏技)
2. WaitGroup の使用 (適切な方法、次)
3. チャネルの使用 (これについては以下で説明します)

Go ルーチンが完了するまで 數(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)
}

これの問題は、ゴルーチンにどれくらいの時間がかかるかわからないことです。場合によっては、それぞれの時間は一定ですが、実際のシナリオでは、ダウンロード時間は変化することがわかっています。

sync.WaitGroup が登場

Go の 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...")

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

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

これを視覚化して、sync.WaitGroup の動作を理解しましょう:

カウンターメカニズム:

• WaitGroup は內(nèi)部カウンターを維持します
• wg.Add(n) はカウンターを n ずつ増やします。
• wg.Done() はカウンターを 1 つデクリメントします
• wg.Wait() はカウンターが 0 に達するまでブロックします。

同期フロー:

• メインの goroutine は goroutine を起動する前に Add(3) を呼び出します
• 各ゴルーチンは完了時に Done() を呼び出します
• メインのゴルーチンは、カウンターが 0 に達するまで Wait() でブロックされます。
• カウンタが 0 に達すると、プログラムは続行され、正常に終了します

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

チャンネル

これで、ゴルーチンがどのように機能するかをよく理解できました。では、2 つの go ルーチンはどのように通信するのでしょうか?ここでチャンネルの出番です。

Go の

Channel は、ゴルーチン間の通信に使用される強力な同時実行プリミティブです。これらは、ゴルーチンがデータを安全に共有する方法を提供します。

チャネルをパイプとして考えてください: 1 つのゴルーチンはデータをチャネルに送信でき、別のゴルーチンはそれを受信できます。

ここにいくつかのプロパティがあります:

1. チャンネルは本質(zhì)的にブロックされています。
2. チャネルに送信 操作 ch <- 値 は、他のゴルーチンがチャネルから受信するまで ブロックされます。
3. チャネルから受信 操作 <-ch ブロックは、他のゴルーチンがチャネルに送信するまで行われます。

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 <- "hello" がデッドロックを引き起こすのはなぜですか?チャネルは本質(zhì)的にブロックしており、ここでは「hello」を渡しているため、レシーバーが存在するまでメインのゴルーチンがブロックされますが、レシーバーがないためスタックします。

ゴルーチンを追加してこれを修正しましょう

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 から送信されているため、チャネルへの送信中にメインはブロックされません。そのため、メッセージは msg := <-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...")

    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 が Done チャネルを作成します
3 つのダウンロードゴルーチンを起動します
各ゴルーチンは同じチャネルへの參照を取得します

ダウンロードの実行:

1. 3 つのダウンロードはすべて同時に実行されます
2. それぞれに 2 秒かかります
3. 任意の順序で終了する可能性があります

チャンネルループ:

1. メインのゴルーチンがループに入ります: for i := 0;私は＜ 3;私
2. 各 <-done は値を受信するまでブロックします
3. ループにより、3 つの完了信號すべてを確実に待機します

ループ動作:

1. 反復 1: 最初のダウンロードが完了するまでブロックします
2. 反復 2: 2 回目のダウンロードが完了するまでブロックします
3. 反復 3: 最終ダウンロードが完了するまでブロックします

完了順序は関係ありません!

所見:
? 各送信 (完了 <- true) には、受信 (<-完了) が 1 つだけあります
? メインのゴルーチンはループを通じてすべてを調(diào)整します

2 つのゴルーチンはどのようにして通信できるのでしょうか?

2 つのゴルーチンがどのように通信できるかはすでに見てきました。いつ？この間ずっと。 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)
}

これを視覚化して予行演習してみましょう:

バッファリングされたチャネル

なぜバッファリングされたチャネルが必要なのでしょうか?
バッファなしチャネルは、相手側(cè)の準備が整うまで送信側(cè)と受信側(cè)の両方をブロックします。高頻度の通信が必要な場合、両方のゴルーチンがデータ交換のために一時停止する必要があるため、バッファーのないチャネルがボトルネックになる可能性があります。

バッファリングされたチャネルのプロパティ:

1. FIFO (先入れ先出し、キューに似ています)
2. 固定サイズ、作成時に設(shè)定
3. バッファがいっぱいの場合に送信者をブロックします
4. バッファが空のときに受信機をブロックします

実際に動作している様子を確認します:

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<-"third" のコメントを解除する前)

なぜメインのゴルーチンをブロックしなかったのでしょうか?

1. バッファリングされたチャネルでは、送信者をブロックせずにその容量まで送信できます。

2. チャネルの容量は 2 です。これは、ブロックする前にバッファーに 2 つの値を保持できることを意味します。

3. バッファは「first」と「next」ですでにいっぱいです。これらの値を同時に消費する受信者が存在しないため、送信操作は無期限にブロックされます。

4. メインの goroutine も送信を擔當しており、チャネルから値を受信するアクティブな goroutine が他にないため、プログラムは 3 番目のメッセージを送信しようとするとデッドロックに入ります。

3 番目のメッセージのコメントを解除すると、現(xiàn)在容量がいっぱいであるためデッドロックが発生し、バッファが解放されるまで 3 番目のメッセージはブロックされます。

バッファー付きチャネルとバッファーなしチャネルを使用する場合

重要なポイント

: の場合、バッファリングされた

1. 送信側(cè)と受信側(cè)のタイミングを切り離す必要があります。
2. メッセージをバッチ処理またはキューに入れると、パフォーマンスが向上します。
3. アプリケーションは、バッファがいっぱいの場合でもメッセージ処理の遅延を許容できます。

: の場合、バッファなし

1. ゴルーチン間の同期は重要です。
2. シンプルさとデータの即時受け渡しが必要です。
3. 送信者と受信者の間の対話は瞬時に行われる必要があります。

これらの基本は、より高度な概念への準備を整えます。今後の投稿では、以下について説明します:

次の投稿:

1. 同時実行パターン
2. ミューテックスとメモリの同期

Go の強力な同時実行機能について理解を深めていきますので、ご期待ください!

以上が直感的なビジュアルで Golang のゴルーチンとチャネルを理解するの詳細內(nèi)容です。詳細については、PHP 中國語 Web サイトの他の関連記事を參照してください。