Go言語におけるGoroutineとChannelの基本的な使い方について解説

package main
import (
	"fmt"
	"time"
)
// printMessage関数は並行して実行される処理を担う
func printMessage(message string) {
	// メッセージ出力の例
	fmt.Println("Goroutine:", message)
}
func main() {
	// goキーワードでprintMessage関数をGoroutineとして起動
	go printMessage("Hello, Goroutine!")
	// 処理待ちのためにsleepを利用
	time.Sleep(100 * time.Millisecond)
	fmt.Println("Main function finished")
}

Goroutine: Hello, Goroutine!
Main function finished

package main
import (
	"fmt"
	"time"
)
func main() {
	text := "Hello from anonymous Goroutine"
	// 無名関数をGoroutineとして実行
	go func(msg string) {
		fmt.Println("Anonymous Goroutine:", msg)
	}(text)
	// 少し待機してGoroutineの実行を確認
	time.Sleep(100 * time.Millisecond)
	fmt.Println("Main function ended")
}

Anonymous Goroutine: Hello from anonymous Goroutine
Main function ended

package main
import (
	"fmt"
	"sync"
)
func process(id int, wg *sync.WaitGroup) {
	// 処理が終了したことを示すためにDoneを呼び出す
	defer wg.Done()
	fmt.Printf("Goroutine %d processing\n", id)
	// 実際の処理はここに記述する
}
func main() {
	var wg sync.WaitGroup
	count := 3
	// 複数のGoroutineを起動するためにループを使用
	for i := 1; i <= count; i++ {
		wg.Add(1)
		go process(i, &wg)
	}
	// 全てのGoroutineが終了するまで待機
	wg.Wait()
	fmt.Println("All goroutines finished")
}

Goroutine 1 processing
Goroutine 2 processing
Goroutine 3 processing
All goroutines finished

package main
import (
	"context"
	"fmt"
	"time"
)
func worker(ctx context.Context, id int) {
	for {
		select {
		case <-ctx.Done():
			// contextのキャンセルが行われた場合に処理を終了する
			fmt.Printf("Worker %d received cancellation signal\n", id)
			return
		default:
			// 通常の処理を実行
			fmt.Printf("Worker %d is processing\n", id)
			time.Sleep(50 * time.Millisecond)
		}
	}
}
func main() {
	// 2秒後にキャンセルシグナルを送るコンテキストを作成
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	// Worker Goroutineを起動
	go worker(ctx, 1)
	go worker(ctx, 2)
	// contextがキャンセルされるまで待機
	<-ctx.Done()
	fmt.Println("All workers stopped")
}

Worker 1 is processing
Worker 2 is processing
Worker 1 is processing
Worker 2 is processing
...
Worker 1 received cancellation signal
Worker 2 received cancellation signal
All workers stopped

package main
import (
	"fmt"
)
func main() {
	// int型のChannelを生成。初期化の際にバッファは設定しない。
	ch := make(chan int)
	// 別のGoroutineでチャンネルに値を送信
	go func() {
		ch <- 42  // 値を送信
	}()
	// 送信された値を受信
	result := <-ch
	fmt.Println("Received value:", result)
}

Received value: 42

package main
import (
	"fmt"
)
func main() {
	// バッファサイズ3のint型Channelを生成
	ch := make(chan int, 3)
	// 複数の値を送信。バッファが許すためブロックされない
	ch <- 1
	ch <- 2
	ch <- 3
	// バッファが空になるまで値を受信
	fmt.Println("Received:", <-ch)
	fmt.Println("Received:", <-ch)
	fmt.Println("Received:", <-ch)
}

Received: 1
Received: 2
Received: 3

package main
import (
	"fmt"
	"time"
)
func main() {
	ch1 := make(chan string)
	ch2 := make(chan string)
	// Goroutineを利用してそれぞれのChannelに値を送信
	go func() {
		time.Sleep(100 * time.Millisecond)
		ch1 <- "Channel 1からのメッセージ"
	}()
	go func() {
		time.Sleep(200 * time.Millisecond)
		ch2 <- "Channel 2からのメッセージ"
	}()
	// select文を利用してどちらか早い送信を受信
	for i := 0; i < 2; i++ {
		select {
		case msg := <-ch1:
			fmt.Println("受信:", msg)
		case msg := <-ch2:
			fmt.Println("受信:", msg)
		}
	}
}

受信: Channel 1からのメッセージ
受信: Channel 2からのメッセージ

package main
import (
	"fmt"
)
func main() {
	ch := make(chan int, 3)
	// Channelに値を送信
	ch <- 10
	ch <- 20
	ch <- 30
	// 送信完了後にChannelをクローズ
	close(ch)
	// Channelのクローズを利用して受信ループを終了
	for value := range ch {
		fmt.Println("Received value:", value)
	}
}

Received value: 10
Received value: 20
Received value: 30

package main
import (
	"fmt"
)
// calculate関数は入力された数値に対して計算を行い、結果をChannelに送信する
func calculate(value int, ch chan int) {
	// 計算例: 値に2を掛ける
	result := value * 2
	// 計算結果をChannelへ送信
	ch <- result
}
func main() {
	// 整数型のChannelを作成(バッファなし)
	ch := make(chan int)
	// 3つのGoroutineを起動して計算を実施
	go calculate(3, ch)
	go calculate(5, ch)
	go calculate(7, ch)
	// すべての計算結果を受信
	sum := 0
	for i := 0; i < 3; i++ {
		sum += <-ch
	}
	fmt.Println("合計結果:", sum)
}

合計結果: 30