Go言語のgoroutineの使いどころについて解説

package main
import (
	"fmt"
	"net/http"
	"sync"
)
// fetchURLは指定したURLにHTTPリクエストを送り、ステータスコードを出力する
func fetchURL(url string, wg *sync.WaitGroup) {
	defer wg.Done() // goroutineの終了を待機グループに通知
	resp, err := http.Get(url)
	if err != nil {
		fmt.Printf("エラーが発生しました(URL: %s): %v\n", url, err)
		return
	}
	defer resp.Body.Close()
	fmt.Printf("URL: %s, ステータスコード: %d\n", url, resp.StatusCode)
}
func main() {
	urls := []string{
		"https://example.com",
		"https://golang.org",
		"https://github.com",
	}
	var wg sync.WaitGroup
	// 各URLに対してgoroutineを起動
	for _, url := range urls {
		wg.Add(1)
		go fetchURL(url, &wg)
	}
	wg.Wait() // 全てのgoroutineが終了するまで待機
	fmt.Println("全てのHTTPリクエストの処理が完了しました")
}

URL: https://example.com, ステータスコード: 200
URL: https://golang.org, ステータスコード: 200
URL: https://github.com, ステータスコード: 200
全てのHTTPリクエストの処理が完了しました

package main
import (
	"bufio"
	"fmt"
	"net"
)
// handleConnectionはクライアントからの接続を処理する
func handleConnection(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	// クライアントから受信した文字列を1行読み込み、出力する
	message, _ := reader.ReadString('\n')
	fmt.Printf("クライアントからのメッセージ: %s", message)
	// クライアントへ返信
	conn.Write([]byte("メッセージを受信しました\n"))
}
func main() {
	ln, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Println("サーバの起動に失敗しました:", err)
		return
	}
	defer ln.Close()
	fmt.Println("TCPサーバがポート8080で稼働中です")
	// クライアントからの接続を待ち受け、goroutineで処理
	for {
		conn, err := ln.Accept()
		if err != nil {
			fmt.Println("接続受け入れエラー:", err)
			continue
		}
		go handleConnection(conn)
	}
}

TCPサーバがポート8080で稼働中です
// (クライアントが接続し、メッセージ送信後にサーバ側で出力される内容)
クライアントからのメッセージ: こんにちは、サーバです

package main
import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)
// processTaskはランダムな時間の待機後、結果を出力するタスクをシミュレーションする
func processTask(taskID int, wg *sync.WaitGroup) {
	defer wg.Done()
	// \( t = rand(1,3) \)秒待機することで処理時間をシミュレーション
	waitTime := time.Duration(rand.Intn(3)+1) * time.Second
	time.Sleep(waitTime)
	fmt.Printf("タスク %d の処理が完了(待機時間: %s)\n", taskID, waitTime)
}
func main() {
	rand.Seed(time.Now().UnixNano())
	var wg sync.WaitGroup
	taskCount := 5
	for i := 1; i <= taskCount; i++ {
		wg.Add(1)
		go processTask(i, &wg)
	}
	wg.Wait()
	fmt.Println("全てのタスクの処理が完了しました")
}

タスク 2 の処理が完了(待機時間: 1s)
タスク 4 の処理が完了(待機時間: 1s)
タスク 1 の処理が完了(待機時間: 2s)
タスク 3 の処理が完了(待機時間: 2s)
タスク 5 の処理が完了(待機時間: 3s)
全てのタスクの処理が完了しました

package main
import (
	"fmt"
)
// generatorは数値を生成し、チャネル経由で送り出す
func generator(nums []int) <-chan int {
	out := make(chan int)
	go func() {
		for _, num := range nums {
			out <- num // 数値をチャネルに送信
		}
		close(out) // 全ての数値を送信後チャネルを閉じる
	}()
	return out
}
// squareは受信した数値の二乗を計算し、チャネルで出力する
func square(in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		for num := range in {
			out <- num * num
		}
		close(out)
	}()
	return out
}
func main() {
	numbers := []int{1, 2, 3, 4, 5}
	// パイプライン処理の各ステージを連結
	gen := generator(numbers)
	sqr := square(gen)
	for result := range sqr {
		fmt.Printf("計算結果: %d\n", result)
	}
}

計算結果: 1
計算結果: 4
計算結果: 9
計算結果: 16
計算結果: 25

package main
import (
	"fmt"
	"sync"
)
func main() {
	var counter int
	var mu sync.Mutex
	var wg sync.WaitGroup
	taskCount := 100
	for i := 0; i < taskCount; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			mu.Lock()   // 排他制御開始
			counter++   // カウンタをインクリメント
			mu.Unlock() // 排他制御終了
		}()
	}
	wg.Wait()
	fmt.Printf("最終カウンタの値: %d\n", counter)
}

最終カウンタの値: 100

package main
import (
	"fmt"
	"sync"
)
// processDataは受信したデータを処理し、結果をチャネルへ送信する
func processData(id int, in int, out chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	// データ処理の例として、数値を倍にする
	result := in * 2
	fmt.Printf("タスク %d: %d -> %d\n", id, in, result)
	out <- result
}
func main() {
	data := []int{1, 2, 3, 4, 5}
	out := make(chan int, len(data))
	var wg sync.WaitGroup
	for i, num := range data {
		wg.Add(1)
		go processData(i+1, num, out, &wg)
	}
	wg.Wait()
	close(out)
	for res := range out {
		fmt.Printf("集約結果: %d\n", res)
	}
}

タスク 1: 1 -> 2
タスク 2: 2 -> 4
タスク 3: 3 -> 6
タスク 4: 4 -> 8
タスク 5: 5 -> 10
集約結果: 2
集約結果: 4
集約結果: 6
集約結果: 8
集約結果: 10

package main
import (
	"context"
	"fmt"
	"time"
)
// performTaskは処理に時間がかかるタスクの例で、Contextのキャンセルを監視する
func performTask(ctx context.Context, taskName string) {
	select {
	case <-time.After(3 * time.Second):
		fmt.Printf("%s の処理が完了しました\n", taskName)
	case <-ctx.Done():
		fmt.Printf("%s の処理がキャンセルされました: %v\n", taskName, ctx.Err())
	}
}
func main() {
	// タイムアウト付きのContextを生成
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	go performTask(ctx, "タスク1")
	// メイン処理はキャンセル信号を待機
	time.Sleep(4 * time.Second)
}

タスク1 の処理がキャンセルされました: context deadline exceeded

package main
import (
	"fmt"
	"sync"
	"time"
)
func asyncProcess(id int, wg *sync.WaitGroup) {
	defer wg.Done()
	time.Sleep(1 * time.Second)
	fmt.Printf("非同期処理 %d の処理が完了しました\n", id)
}
func main() {
	var wg sync.WaitGroup
	for i := 1; i <= 5; i++ {
		wg.Add(1)
		go asyncProcess(i, &wg)
	}
	wg.Wait()
	fmt.Println("全ての非同期処理が終了しました")
}

非同期処理 1 の処理が完了しました
非同期処理 2 の処理が完了しました
非同期処理 3 の処理が完了しました
非同期処理 4 の処理が完了しました
非同期処理 5 の処理が完了しました
全ての非同期処理が終了しました

package main
import (
	"fmt"
	"time"
)
// simpleTaskは指定した待機時間後に結果を出力するタスクの例
func simpleTask(taskName string, waitTime time.Duration) {
	time.Sleep(waitTime)
	fmt.Printf("%s の処理が完了しました(待機時間: %s)\n", taskName, waitTime)
}
func main() {
	// 複数のタスクをgoroutineで実行
	go simpleTask("タスクA", 1*time.Second)
	go simpleTask("タスクB", 2*time.Second)
	go simpleTask("タスクC", 1*time.Second)
	// 全goroutineが実行完了するのを簡易的に待機(実際の環境ではWaitGroupを推奨)
	time.Sleep(3 * time.Second)
}

タスクA の処理が完了しました(待機時間: 1s)
タスクC の処理が完了しました(待機時間: 1s)
タスクB の処理が完了しました(待機時間: 2s)

package main
import (
	"errors"
	"fmt"
	"sync"
	"time"
)
// errorProneTaskはエラーを発生する可能性のあるタスクの例
func errorProneTask(taskID int, wg *sync.WaitGroup, errCh chan<- error) {
	defer wg.Done()
	// 擬似的なエラー発生条件(偶数のタスクIDの場合エラーを返す)
	time.Sleep(500 * time.Millisecond)
	if taskID%2 == 0 {
		errCh <- errors.New(fmt.Sprintf("タスク %d でエラーが発生しました", taskID))
		return
	}
	fmt.Printf("タスク %d は正常に完了しました\n", taskID)
}
func main() {
	taskCount := 4
	var wg sync.WaitGroup
	errCh := make(chan error, taskCount)
	for i := 1; i <= taskCount; i++ {
		wg.Add(1)
		go errorProneTask(i, &wg, errCh)
	}
	wg.Wait()
	close(errCh)
	// エラーがある場合は全て出力する
	for err := range errCh {
		fmt.Println("エラー情報:", err)
	}
}

タスク 1 は正常に完了しました
タスク 3 は正常に完了しました
エラー情報: タスク 2 でエラーが発生しました
エラー情報: タスク 4 でエラーが発生しました

package main
import (
	"fmt"
	"sync"
	"time"
)
// fetchDataは内部APIからデータを取得するシミュレーション
func fetchData(apiName string, wg *sync.WaitGroup, dataCh chan<- string) {
	defer wg.Done()
	time.Sleep(1 * time.Second) // 擬似的なAPI応答待ち
	result := fmt.Sprintf("%s のデータ", apiName)
	dataCh <- result
}
func main() {
	apis := []string{"API_A", "API_B", "API_C"}
	var wg sync.WaitGroup
	dataCh := make(chan string, len(apis))
	for _, api := range apis {
		wg.Add(1)
		go fetchData(api, &wg, dataCh)
	}
	wg.Wait()
	close(dataCh)
	// 各APIの返却データを集約する
	var combinedResult []string
	for data := range dataCh {
		combinedResult = append(combinedResult, data)
	}
	fmt.Printf("最終的なレスポンス: %v\n", combinedResult)
}

最終的なレスポンス: [API_A のデータ API_B のデータ API_C のデータ]

package main
import (
	"fmt"
	"sync"
	"time"
)
// limitedTaskは同時実行数を制御されたタスクの例
func limitedTask(id int, wg *sync.WaitGroup, sem chan struct{}) {
	defer wg.Done()
	// 実行開始前にセマフォからスロットを取得
	sem <- struct{}{}
	defer func() { <-sem }() // タスク完了後スロットを解放
	time.Sleep(1 * time.Second)
	fmt.Printf("タスク %d が完了しました\n", id)
}
func main() {
	taskCount := 10
	workerLimit := 3 // 同時に実行可能なgoroutine数
	sem := make(chan struct{}, workerLimit)
	var wg sync.WaitGroup
	for i := 1; i <= taskCount; i++ {
		wg.Add(1)
		go limitedTask(i, &wg, sem)
	}
	wg.Wait()
	fmt.Println("全てのタスクが完了しました")
}

タスク 1 が完了しました
タスク 2 が完了しました
タスク 3 が完了しました
タスク 4 が完了しました
タスク 5 が完了しました
タスク 6 が完了しました
タスク 7 が完了しました
タスク 8 が完了しました
タスク 9 が完了しました
タスク 10 が完了しました
全てのタスクが完了しました

package main
import (
	"fmt"
	"net/http"
	_ "net/http/pprof" // pprofをインポートすることでエンドポイントが有効化される
	"time"
)
func main() {
	// 定期的にシンプルなタスクを実行する例
	go func() {
		for {
			fmt.Println("定期タスク実行中...")
			time.Sleep(2 * time.Second)
		}
	}()
	// pprofのデフォルトエンドポイントをポート6060で起動
	fmt.Println("pprofサーバをポート6060で起動中")
	http.ListenAndServe(":6060", nil)
}

定期タスク実行中...
定期タスク実行中...
// コンソールには定期タスクのログが出力され、pprofエンドポイントで詳細情報を参照可能

package main
import (
	"fmt"
	"sync"
	"time"
)
// tracedTaskはタスクIDをログに出力しながら処理を行う例
func tracedTask(taskID int, wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Printf("タスク %d 開始\n", taskID)
	time.Sleep(1 * time.Second)
	fmt.Printf("タスク %d 完了\n", taskID)
}
func main() {
	taskCount := 3
	var wg sync.WaitGroup
	for i := 1; i <= taskCount; i++ {
		wg.Add(1)
		go tracedTask(i, &wg)
	}
	wg.Wait()
	fmt.Println("全タスクの処理終了")
}

タスク 1 開始
タスク 2 開始
タスク 3 開始
タスク 1 完了
タスク 2 完了
タスク 3 完了
全タスクの処理終了