Go言語（Golang）のgoroutine（ゴルーチン／ゴールーチン）の使い所まとめ

package main

import (
    "fmt"
    "time"
)

// チャネルへのメッセージ送信処理
func sendMessage(ch chan<- string, count int) {
    for i := 1; i <= count; i++ {
        // 送信メッセージを生成
        msg := fmt.Sprintf("メッセージ %d", i)

        // チャネルにメッセージを送信
        ch <- msg

        // 待機処理
        time.Sleep(500 * time.Millisecond)
    }

    // チャネルをクローズ
    close(ch)
}

func main() {
    // string型のデータを送受信するチャネルを作成
    textChan := make(chan string)

    // メッセージ送信回数
    count := 3

    // ゴルーチンを実行してメッセージ送信
    go sendMessage(textChan, count)

    // チャネルがクローズするまで受信処理
    fmt.Println("受信待機中...")
    for msg := range textChan {
        fmt.Printf("受信: %s\n", msg)
    }

    fmt.Println("処理完了")
}

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    // 処理完了後にwg.Done()を呼んで完了させる
    defer wg.Done()

    fmt.Printf("ワーカー %d: 処理開始\n", id)

    // 待機処理
    time.Sleep(1 * time.Second)

    fmt.Printf("ワーカー %d: 処理完了\n", id)
}

func main() {
    // WaitGroupの定義
    var wg sync.WaitGroup

    // ワーカー数の定義
    numWorkers := 3

    // ワーカー関数を実行
    for i := 1; i <= numWorkers; i++ {
        // WaitGroupのカウンターを一つ増やす
        wg.Add(1)

        // ワーカーをゴルーチンで非同期実行
        go worker(i, &wg)
    }

    fmt.Println("全てのワーカーの完了待ち...")
    wg.Wait()

    fmt.Println("全てのワーカー処理が完了しました。")
}

package main

import (
    "fmt"
    "time"
)

// 何らかの重いタスクの処理
func heavyTask(done chan<- bool) {
    fmt.Println("タスクを開始...")

    // 待機処理
    time.Sleep(3 * time.Second)

    fmt.Println("タスク完了")
    // 完了通知としてチャネルに値を送信
    done <- true
}

func main() {
    // 通知用チャネルの定義
    doneChan := make(chan bool)

    // ゴルーチンによりタスク実行
    go heavyTask(doneChan)

    fmt.Println("タスクの完了通知を待っています...")
    <-doneChan

    fmt.Println("メイン処理を終了します。")
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    // カウンターの定義
    var counter int

    // WaitGroupの定義
    var wg sync.WaitGroup

    // ミューテックスの定義
    var mu sync.Mutex

    // ゴルーチンの回数設定
    numGoroutines := 100
    wg.Add(numGoroutines)

    // ゴルーチンを実行
    for i := 0; i < numGoroutines; i++ {
      // 即時関数で実行する
      go func() {
          defer wg.Done()

          // カウンターへのロック
          mu.Lock()
          counter++
          // アンロック
          mu.Unlock()
      }()
    }

    // ゴルーチンの完了待ち
    wg.Wait()

    // カウンターの値がゴルーチンの回数設定と同じ値になること
    fmt.Printf("最終カウンター: %d\n", counter)
}

package main

import (
    "fmt"
    "sync"
)

// カウンター管理用の関数
func counterManager(requests <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()

    // カウンターの定義
    var counter int

    // チャネルがクローズするまで受信処理
    for range requests {
        counter++
    }

    fmt.Printf("最終カウンター: %d\n", counter)
}

func main() {
    // リクエスト用のチャネルを定義
    requests := make(chan int)

    // カウンター管理用のWaitGroupの定義
    var wgCM sync.WaitGroup

    // ゴルーチン用のWaitGroupの定義
    var wgG sync.WaitGroup

    // カウンター管理用のゴルーチンを起動
    wgCM.Add(1)
    go counterManager(requests, &wgCM)

    // ゴルーチンの回数設定
    numGoroutines := 100
    wgG.Add(numGoroutines)

    // ゴルーチンを実行
    for i := 0; i < numGoroutines; i++ {
      // 即時関数で実行する
      go func() {
          defer wgG.Done()

          // カウンターにリクエストを送信
          requests <- 1
      }()
    }

    // ゴルーチンの完了待ち
    wgG.Wait()

    // リクエスト用のチャネルをクローズ
    close(requests)

    // カウンター管理用ゴルーチンの完了待ち
    wgCM.Wait()
}

package main

import (
    "fmt"
    "time"
)

// タスク実行処理（戻り値に受信用のチャネルを返す）
func task(name string, delay time.Duration) <-chan string {
    // 戻り値用のチャネルを定義
    resultChan := make(chan string)

    // ゴルーチンを実行
    go func() {
        // 待機処理
        time.Sleep(delay)

        // チャネルにテキストを送信
        resultChan <- fmt.Sprintf("%sが完了しました！", name)
    }()

    // 戻り値にチャネルを返す
    return resultChan
}

func main() {
    // 2つのタスクを並行で実行
    result1 := task("タスクA", 5*time.Second)
    result2 := task("タスクB", 2*time.Second)

    fmt.Println("タスク完了待ち...")

    // チャネル用のselect文を用いた待機処理
    // 最初に受信した結果に応じた処理を実行するか、タイムアウト処理を実行する
    select {
    case res := <-result1:
        fmt.Println(res)
    case res := <-result2:
        fmt.Println(res)
    case <-time.After(10 * time.Second):
        fmt.Println("タイムアウトしました！")
    }  
}