Go並行処理

並行処理とは、プログラムが同時に複数のタスクを実行する能力のことです。

Go 言語は並行処理をサポートし、goroutines と channels を通じて、シンプルで効率的な並行処理の実装方法を提供します。

Goroutines:

  • Go における並行処理の実行単位で、軽量なスレッドに似ています。
  • Goroutine のスケジューリングは Go ランタイムによって管理され、ユーザーが手動でスレッドを割り当てる必要はありません。
  • go キーワードを使用してgoGoroutine を起動します。
  • Goroutine はノンブロッキングであり、何千何万もの Goroutine を効率的に実行できます。

Channel:

  • Go において Goroutine 間で通信するための仕組みです。
  • 同期とデータ共有をサポートし、明示的なロック機構を避けます。
  • chan キーワードを使用してchan作成し、<- 演算子で<-データを送受信します。

Scheduler(スケジューラ):

Go のスケジューラは GMP モデルに基づいており、Goroutine をシステムスレッドに割り当てて実行し、M と P の連携によって並行処理を効率的に管理します。

  • G:Goroutine。
  • M:システムスレッド(Machine)。
  • P:論理プロセッサ(Processor)。

Goroutine

goroutine は軽量なスレッドであり、goroutine のスケジューリングは Golang ランタイムによって管理されます。

goroutine の構文形式:

go 函数名( 参数列表 )

例:

go f(x, y, z)

新しい goroutine を起動する:

f(x, y, z)

Go では、go 文を使用して新しい実行時スレッド、すなわち goroutine を起動し、新しく作成された別の goroutine で関数を実行できます。同じプログラム内のすべての goroutine は同じアドレス空間を共有します。

例

package main

import (
        "fmt"
        "time"
)

func sayHello() {
        for i := 0; i < 5; i++ {
                fmt.Println("Hello")
                time.Sleep(100 * time.Millisecond)
        }
}

func main() {
        go sayHello() // Goroutine を起動
        for i := 0; i < 5; i++ {
                fmt.Println("Main")
                time.Sleep(100 * time.Millisecond)
        }
}

上記のコードを実行すると、出力に Main と Hello が表示されます。出力には固定された順序はありません。これらは 2 つの goroutine によって実行されるためです:

Main
Hello
Main
Hello
...

チャネル(Channel)

チャネル(Channel)は Goroutine 間のデータ受け渡しに使用されます。

チャネルは、指定された型の値を渡すことで、2 つの goroutine 間の同期実行と通信に使用できます。

make 関数を使用してmakechannel を作成し、<- 演算子で<-データを送受信します。方向が指定されていない場合は、双方向チャネルになります。

ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据
           // 并把值赋给 v

チャネルの宣言はとても簡単で、chan キーワードを使用するだけです。チャネルは使用する前に必ず作成する必要があります:

ch := make(chan int)

注意:デフォルトでは、チャネルにはバッファがありません。送信側がデータを送信するとき、同時に受信側が対応するデータを受信する必要があります。

次の例では、2 つの goroutine を使用して数値の合計を計算しています。各 goroutine が計算を完了した後、2 つの結果の合計を計算します:

例

package main

import "fmt"

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // sum をチャネル c に送信
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // チャネル c から受信

    fmt.Println(x, y, x+y)
}

出力結果は次のとおりです:

-5 17 12

チャネルのバッファ

チャネルにはバッファを設定できます。make の 2 番目のパラメータでバッファサイズを指定します:

ch := make(chan int, 100)

バッファ付きチャネルでは、送信側のデータ送信と受信側のデータ取得を非同期にできます。つまり、送信側が送信したデータはバッファに格納され、受信側がデータを取得するのを待つことができます。受信側がすぐにデータを取得する必要はありません。

ただし、バッファのサイズは有限であるため、受信側がデータを受信する必要があります。そうしないと、バッファがいっぱいになると、送信側はデータを送信できなくなります。

注意:バッファがないチャネルの場合、送信側は受信側がチャネルから値を受信するまでブロックされます。バッファ付きチャネルの場合、送信側は送信された値がバッファにコピーされるまでブロックされます。バッファが満杯の場合は、いずれかの受信側が値を受け取るまで待つ必要があることを意味します。受信側は、受信できる値があるまでブロックされ続けます。

例

package main

import "fmt"

func main() {
    // ここでは整数型を格納できるバッファ付きチャネルを定義します
    // バッファサイズは 2
    ch := make(chan int, 2)

    // ch はバッファ付きチャネルなので、2 つのデータを同時に送信できます
    // すぐに同期読み取りをする必要はありません
    ch <- 1
    ch <- 2

    // この 2 つのデータを取得します
    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

実行した出力結果は次のとおりです:

1
2

Go でのチャネル走査とチャネルのクローズ

Go は range キーワードを使用して受信したデータを走査します。これは配列やスライスと同様です。形式は次のとおりです:

v, ok := <-ch

チャネルがデータを受信できず ok が false になる場合、チャネルは close 関数を使用してclose()閉じることができます。

例

package main

import (
    "fmt"
)

func fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    // range 関数はチャネルから受信した各データを走査します。c は 10 個のデータを送信し終えた後
    // チャネルを閉じたため、この range 関数は 10 個のデータを受信した時点で
    // 終了します。上記の c チャネルを閉じない場合、range 関数は
    // 終了せず、11 個目のデータを受信するときにブロックされます。
    for i := range c {
        fmt.Println(i)
    }
}

実行した出力結果は次のとおりです:

0
1
1
2
3
5
8
13
21
34

Select 文

selectSelect 文により、1 つの goroutine が複数の通信操作を待機できるようになります。selectいずれかの case が実行可能になるまでブロックされます:

例

package main

import "fmt"

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case <-quit:
            fmt.Println("quit")
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)

    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 0
    }()
    fibonacci(c, quit)
}

上記のコードでは、fibonaccigoroutine はチャネルc上でフィボナッチ数列を送信し、チャネルからquitシグナルを受信すると終了します。

実行した出力結果は次のとおりです:

0
1
1
2
3
5
8
13
21
34
quit

WaitGroup の使用

sync.WaitGroup は、複数の Goroutine の完了を待機するために使用されます。

複数の Goroutine を同期する:

例

package main

import (
        "fmt"
        "sync"
)

func worker(id int, wg *sync.WaitGroup) {
        defer wg.Done() // Goroutine が完了したら Done() を呼び出す
        fmt.Printf("Worker %d started\n", id)
        fmt.Printf("Worker %d finished\n", id)
}

func main() {
        var wg sync.WaitGroup

        for i := 1; i <= 3; i++ {
                wg.Add(1) // カウンタを増加させる
                go worker(i, &wg)
        }

        wg.Wait() // すべての Goroutine の完了を待つ
        fmt.Println("All workers done")
}

上記のコードを実行した出力結果は次のとおりです:

Worker 1 started
Worker 1 finished
Worker 2 started
Worker 2 finished
Worker 3 started
Worker 3 finished
All workers done

高度な機能

Buffered Channel:

バッファ付き Channel を作成します。

ch := make(chan int, 2)

Context:

Goroutine のライフサイクルを制御するために使用します。

context.WithCancel、context.WithTimeout。

Mutex と RWMutex:

sync.Mutex は相互排他ロックを提供し、共有リソースを保護するために使用します。

var mu sync.Mutex
mu.Lock()
// critical section
mu.Unlock()

並行プログラミングのまとめ

Go 言語は Goroutine と Channel を通じて強力な並行処理サポートを提供し、従来のスレッドモデルの複雑さを簡素化します。スケジューラと同期ツールを組み合わせることで、高性能な並行プログラムを簡単に実装できます。

  • Goroutinesは軽量なスレッドであり、go キーワードを使用してgo起動します。
  • Channelsgoroutines 間の通信に使用します。
  • Select 文複数の channel 操作を待機するために使用します。

よくある質問

デッドロック (Deadlock):

  • 例:すべての Goroutine が待機中であるが、利用可能なデータがありません。
  • 解決策:無限待機を避け、チャネルを正しく閉じる。

データ競合 (Data Race):

  • 例:複数の Goroutine が同じ変数に同時にアクセスします。
  • 解決策:Mutex または Channel を使用してアクセスを同期する。
その他の拡張