Go言語におけるgoroutine終了待ちの実装方法について解説

// サンプルコード: sync.WaitGroupの基本操作例
package main
import (
	"fmt"
	"sync"
)
func main() {
	// WaitGroupのインスタンス作成
	var wg sync.WaitGroup
	// 2つのゴルーチンが完了するのを待つために2を追加
	wg.Add(2)
	// 1つ目のゴルーチンを起動
	go func() {
		// 処理完了時にカウンターを減らす
		defer wg.Done()
		fmt.Println("ゴルーチン1終了")
	}()
	// 2つ目のゴルーチンを起動
	go func() {
		defer wg.Done()
		fmt.Println("ゴルーチン2終了")
	}()
	// すべてのゴルーチンが終了するまで待機
	wg.Wait()
	fmt.Println("すべてのゴルーチン終了")
}

ゴルーチン1終了
ゴルーチン2終了
すべてのゴルーチン終了

// サンプルコード: goroutineの起動例
package main
import (
	"fmt"
)
func main() {
	// 単純なgoroutineの起動
	go func() {
		fmt.Println("新しいゴルーチンが実行中")
	}()
	// 実行順は保証されないため、メイン処理が終了しないように工夫が必要
	fmt.Scanln() // 入力待ちでプログラム終了を防止
}

新しいゴルーチンが実行中

// サンプルコード: 終了通知の実装例
package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	var wg sync.WaitGroup
	// 1つのgoroutineに対してカウンターを増加
	wg.Add(1)
	go func() {
		defer wg.Done() // 終了時に通知
		fmt.Println("処理中...")
		time.Sleep(1 * time.Second)
		fmt.Println("処理完了")
	}()
	// すべてのgoroutineが終了するまで待機
	wg.Wait()
	fmt.Println("すべての終了通知を受信")
}

処理中...
処理完了
すべての終了通知を受信

// サンプルコード: シンプルなチャネル実装例
package main
import (
	"fmt"
	"time"
)
func main() {
	// 終了通知用のチャネルを作成。バッファサイズはgoroutine数に合わせる
	done := make(chan bool, 2)
	// 1つ目のgoroutineを起動
	go func() {
		fmt.Println("ゴルーチン①処理開始")
		time.Sleep(500 * time.Millisecond)
		fmt.Println("ゴルーチン①処理完了")
		done <- true // 終了通知を送信
	}()
	// 2つ目のgoroutineを起動
	go func() {
		fmt.Println("ゴルーチン②処理開始")
		time.Sleep(700 * time.Millisecond)
		fmt.Println("ゴルーチン②処理完了")
		done <- true // 終了通知を送信
	}()
	// 2つの終了通知を受信するまで待機
	<-done
	<-done
	fmt.Println("すべてのゴルーチンが終了")
}

ゴルーチン①処理開始
ゴルーチン②処理開始
ゴルーチン①処理完了
ゴルーチン②処理完了
すべてのゴルーチンが終了

// サンプルコード: select文とチャネルを組み合わせた例
package main
import (
	"fmt"
	"time"
)
func main() {
	done := make(chan string, 1) // 終了通知用のチャネル
	go func() {
		// 長い処理をシミュレーション
		time.Sleep(2 * time.Second)
		done <- "ゴルーチン終了"
	}()
	// select文を利用して終了通知かタイムアウトを待機
	select {
	case msg := <-done:
		fmt.Println(msg)
	case <-time.After(1 * time.Second):
		fmt.Println("タイムアウト：処理が時間内に終了しませんでした")
	}
}

タイムアウト：処理が時間内に終了しませんでした

// サンプルコード: エラーハンドリングの実践例
package main
import (
	"errors"
	"fmt"
	"time"
)
func worker(id int, errChan chan error) {
	// サンプル処理。idが偶数の場合にエラーを返す
	time.Sleep(time.Duration(id) * 100 * time.Millisecond)
	if id%2 == 0 {
		errChan <- errors.New(fmt.Sprintf("worker %dでエラー発生", id))
		return
	}
	errChan <- nil
}
func main() {
	numWorkers := 4
	errChan := make(chan error, numWorkers)
	// 複数のworkerごとにgoroutineを起動
	for i := 1; i <= numWorkers; i++ {
		go worker(i, errChan)
	}
	// 各workerからのエラーを収集
	for i := 1; i <= numWorkers; i++ {
		err := <-errChan
		if err != nil {
			fmt.Println("エラー:", err)
		} else {
			fmt.Println("worker", i, "は正常終了")
		}
	}
	fmt.Println("すべてのworker処理完了")
}

worker 1 は正常終了
エラー: worker 2でエラー発生
worker 3 は正常終了
エラー: worker 4でエラー発生
すべてのworker処理完了

// サンプルコード: タイムアウトを利用したデッドロック回避例
package main
import (
	"fmt"
	"time"
)
func longProcess(done chan bool) {
	// 処理に時間がかかる場合をシミュレート
	time.Sleep(3 * time.Second)
	done <- true
}
func main() {
	done := make(chan bool, 1)
	go longProcess(done)
	// select文でタイムアウトを設定して待機
	select {
	case result := <-done:
		if result {
			fmt.Println("処理完了")
		}
	case <-time.After(1 * time.Second):
		fmt.Println("タイムアウト：処理が遅延中")
	}
}

タイムアウト：処理が遅延中