Go言語 – 並列処理について解説：GoroutineとChannelによる効率的な実装方法

package main
import (
	"fmt"
	"time"
)
// printMessageは単純なメッセージを出力する関数です。
func printMessage(message string) {
	fmt.Println(message)
}
func main() {
	// goroutineを利用して非同期にprintMessageを実行
	go printMessage("Hello from goroutine!") // 別スレッドで実行
	// メイン処理も同時に実行
	fmt.Println("Hello from main function!")
	// goroutineの出力結果を受け取るために待機
	time.Sleep(100 * time.Millisecond)
}

Hello from main function!
Hello from goroutine!

package main
import "fmt"
func main() {
	// 整数を送受信するchannelを作成
	messageChannel := make(chan int)
	// goroutine内で値をchannelに送信
	go func() {
		messageChannel <- 42 // channelへ42を送信
	}()
	// channelから値を受信して出力
	result := <-messageChannel
	fmt.Println("Received value:", result)
}

Received value: 42

package main
import (
	"fmt"
	"time"
)
func printNumber(num int) {
	// 数字を表示
	fmt.Println("Number:", num)
}
func main() {
	for i := 0; i < 5; i++ {
		// 各ループで新しいgoroutineを生成し、非同期にprintNumberを実行
		go printNumber(i)
	}
	// 全てのgoroutineが終了するのを待つために少し待機
	time.Sleep(200 * time.Millisecond)
}

Number: 0
Number: 1
Number: 2
Number: 3
Number: 4

package main
import (
	"fmt"
	"time"
)
// processDataは与えられた整数を倍にして返す関数です。
func processData(input int, resultChannel chan int) {
	// シンプルな処理として2倍にする
	resultChannel <- input * 2
}
func main() {
	// 結果を受信するchannelを作成
	resultChannel := make(chan int)
	// 非同期にprocessDataを実行
	go processData(10, resultChannel)
	// 結果をchannelから受信して出力
	result := <-resultChannel
	fmt.Println("Processed result:", result)
	// goroutineの終了を待機
	time.Sleep(50 * time.Millisecond)
}

Processed result: 20

package main
import "fmt"
func main() {
	// バッファサイズ3のchannelを作成
	bufferedChannel := make(chan string, 3)
	// channelに値を送信
	bufferedChannel <- "Message 1"
	bufferedChannel <- "Message 2"
	bufferedChannel <- "Message 3"
	// channelから順次値を受信して出力
	for i := 0; i < 3; i++ {
		fmt.Println("Received:", <-bufferedChannel)
	}
}

Received: Message 1
Received: Message 2
Received: Message 3

package main
import (
	"fmt"
	"time"
)
func main() {
	// バッファサイズ2のchannelを作成
	dataChannel := make(chan int, 2)
	// goroutineでchannelにデータを送信
	go func() {
		for i := 1; i <= 4; i++ {
			dataChannel <- i
			fmt.Println("Sent:", i)
		}
		// channelを閉じることで受信側に完了を通知
		close(dataChannel)
	}()
	// channelからデータを受信して出力
	for num := range dataChannel {
		fmt.Println("Received:", num)
		time.Sleep(50 * time.Millisecond)
	}
}

Sent: 1
Sent: 2
Received: 1
Received: 2
Sent: 3
Sent: 4
Received: 3
Received: 4

package main
import (
	"fmt"
	"time"
)
// computeTaskは入力値の二乗を計算しchannelへ送信する関数です。
func computeTask(input int, resultChannel chan int) {
	result := input * input // 二乗計算
	resultChannel <- result
}
func main() {
	// 結果送信用のchannelを作成
	resultChannel := make(chan int, 5)
	// 複数のタスクをgoroutineで分散処理
	for i := 1; i <= 5; i++ {
		go computeTask(i, resultChannel)
	}
	// 全てのタスクの結果を受信
	for i := 0; i < 5; i++ {
		fmt.Println("Result:", <-resultChannel)
	}
	// 少し待機して全goroutineの完了を確認
	time.Sleep(100 * time.Millisecond)
}

Result: 1
Result: 4
Result: 9
Result: 16
Result: 25

package main
import (
	"fmt"
	"time"
)
// performWorkは入力に対して簡単な計算を行い、結果をchannelへ送信する関数です。
func performWork(input int, resultChannel chan int) {
	// 入力値に一定の処理を実施(今回は単純な四則演算)
	resultChannel <- input + 10
}
func main() {
	// 結果を格納するためのchannelを作成
	resultChannel := make(chan int, 3)
	// 複数の作業をgoroutineで実行
	inputs := []int{5, 15, 25}
	for _, val := range inputs {
		go performWork(val, resultChannel)
	}
	// 作業結果を受信して出力
	for i := 0; i < len(inputs); i++ {
		fmt.Println("Final Result:", <-resultChannel)
	}
	// 少し待機して、全てのgoroutine実行を確認
	time.Sleep(100 * time.Millisecond)
}

Final Result: 15
Final Result: 25
Final Result: 35

package main
import (
	"errors"
	"fmt"
	"time"
)
// processTaskは入力値に対して処理を行い、エラーがあればエラーチャネルへ送信する関数です。
func processTask(input int, resultChannel chan int, errorChannel chan error) {
	// シンプルな処理。条件によりエラーを返す
	if input < 0 {
		errorChannel <- errors.New("negative input error")
		return
	}
	resultChannel <- input * 3
}
func main() {
	resultChannel := make(chan int, 3)
	errorChannel := make(chan error, 3)
	inputs := []int{3, -1, 7}
	for _, val := range inputs {
		go processTask(val, resultChannel, errorChannel)
	}
	// 結果とエラーの受信処理
	for i := 0; i < len(inputs); i++ {
		select {
		case res := <-resultChannel:
			fmt.Println("Processed result:", res)
		case err := <-errorChannel:
			fmt.Println("Error occurred:", err)
		}
	}
	time.Sleep(100 * time.Millisecond)
}

Processed result: 9
Error occurred: negative input error
Processed result: 21

package main
import (
	"fmt"
	"net/http"
	_ "net/http/pprof"
	"time"
)
func simulateWork(id int) {
	// 擬似的な処理、実行時間のシミュレーション
	time.Sleep(time.Duration(id) * 100 * time.Millisecond)
	fmt.Println("Work done by goroutine", id)
}
func main() {
	// pprofのWebインターフェースを非同期で開始
	go func() {
		fmt.Println("pprof listening on :6060")
		http.ListenAndServe(":6060", nil)
	}()
	// 複数のgoroutineでsimulateWorkを並行実行
	for i := 1; i <= 3; i++ {
		go simulateWork(i)
	}
	// 全てのgoroutineの完了を待機
	time.Sleep(500 * time.Millisecond)
	fmt.Println("All work completed")
}

pprof listening on :6060
Work done by goroutine 1
Work done by goroutine 2
Work done by goroutine 3
All work completed