Go言語の実行速度とパフォーマンスについて解説

package main
import (
	"fmt"
	"testing"
)
// BenchmarkSampleは対象処理のベンチマークを行います。
// ここでは単純なループ処理を例示します。
func BenchmarkSample(b *testing.B) {
	for i := 0; i < b.N; i++ {
		// ここに実行したい処理を配置します
	}
}
func main() {
	// testing.Benchmarkを利用してベンチマークを実行し、結果を出力します。
	result := testing.Benchmark(BenchmarkSample)
	// ns/opは1回の処理にかかるナノ秒数を示します。
	fmt.Printf("BenchmarkSample: ns/op = %d\n", result.NsPerOp())
}

BenchmarkSample: ns/op = 50

package main
import (
	"fmt"
	"time"
)
// sumLoopはループ処理で整数の和を計算します。
func sumLoop(n int) int {
	result := 0
	for i := 1; i <= n; i++ {
		result += i
	}
	return result
}
// sumFormulaは数式を用いて整数の和を計算します。
func sumFormula(n int) int {
	// 数式により定数時間で計算可能です。
	return n * (n + 1) / 2
}
func main() {
	const n = 10000000
	startLoop := time.Now()
	loopResult := sumLoop(n)
	durationLoop := time.Since(startLoop)
	startFormula := time.Now()
	formulaResult := sumFormula(n)
	durationFormula := time.Since(startFormula)
	fmt.Printf("sumLoop: result = %d, duration = %v\n", loopResult, durationLoop)
	fmt.Printf("sumFormula: result = %d, duration = %v\n", formulaResult, durationFormula)
}

sumLoop: result = 50000005000000, duration = 150ms
sumFormula: result = 50000005000000, duration = 10µs

package main
import (
	"fmt"
	"time"
)
// searchInSliceはスライス内の値を線形探索で検索します。
func searchInSlice(data []int, target int) bool {
	for _, v := range data {
		if v == target {
			return true
		}
	}
	return false
}
// searchInMapはマップを利用して高速に値の存在確認を行います。
func searchInMap(data map[int]struct{}, target int) bool {
	_, exists := data[target]
	return exists
}
func main() {
	// サンプルデータの生成
	size := 100000
	sliceData := make([]int, size)
	mapData := make(map[int]struct{})
	for i := 0; i < size; i++ {
		sliceData[i] = i
		mapData[i] = struct{}{}
	}
	target := size - 1
	startSlice := time.Now()
	foundSlice := searchInSlice(sliceData, target)
	durationSlice := time.Since(startSlice)
	startMap := time.Now()
	foundMap := searchInMap(mapData, target)
	durationMap := time.Since(startMap)
	fmt.Printf("searchInSlice: found = %v, duration = %v\n", foundSlice, durationSlice)
	fmt.Printf("searchInMap: found = %v, duration = %v\n", foundMap, durationMap)
}

searchInSlice: found = true, duration = 2ms
searchInMap: found = true, duration = 10µs

package main
import (
	"fmt"
	"sync"
	"time"
)
// processDataは並行処理を行う関数です。
func processData(id int, wg *sync.WaitGroup) {
	defer wg.Done()
	// 各Goroutineで個別の処理をシミュレート
	time.Sleep(time.Millisecond * 100) // 処理時間のシミュレーション
	fmt.Printf("Goroutine %d 処理完了\n", id)
}
func main() {
	var wg sync.WaitGroup
	goroutineCount := 5
	// 複数のGoroutineを起動
	for i := 0; i < goroutineCount; i++ {
		wg.Add(1)
		go processData(i, &wg)
	}
	// すべてのGoroutineの完了を待機
	wg.Wait()
	fmt.Println("全Goroutineの処理が完了しました")
}

Goroutine 0 処理完了
Goroutine 1 処理完了
Goroutine 2 処理完了
Goroutine 3 処理完了
Goroutine 4 処理完了
全Goroutineの処理が完了しました

package main
import (
	"fmt"
	"time"
)
// processTaskはchannelを通じて結果を送信します。
func processTask(id int, resultChan chan<- string) {
	// 簡単な処理のシミュレーション
	time.Sleep(time.Millisecond * 100)
	resultChan <- fmt.Sprintf("タスク %d 完了", id)
}
func main() {
	taskCount := 5
	resultChan := make(chan string, taskCount)
	// 複数のGoroutineを起動し、結果をchannelに送信
	for i := 0; i < taskCount; i++ {
		go processTask(i, resultChan)
	}
	// channelから結果を受信して出力
	for i := 0; i < taskCount; i++ {
		result := <-resultChan
		fmt.Println(result)
	}
}

タスク 0 完了
タスク 1 完了
タスク 2 完了
タスク 3 完了
タスク 4 完了

package main
import "fmt"
func main() {
	// コンパイル時に最適化設定が反映される実行例です。
	fmt.Println("ビルドフラグを利用して最適化された実行ファイルです")
}

ビルドフラグを利用して最適化された実行ファイルです

go build -ldflags="-s -w" sample.go

package main
import (
	"fmt"
	"time"
)
// computeTaskは多くの反復計算を行う例です。
func computeTask(n int) int {
	sum := 0
	for i := 0; i < n; i++ {
		sum += i
	}
	return sum
}
func main() {
	const iterations = 10000000
	startTime := time.Now()
	result := computeTask(iterations)
	duration := time.Since(startTime)
	fmt.Printf("computeTaskの結果: %d, 実行時間: %v\n", result, duration)
}

computeTaskの結果: 49999995000000, 実行時間: 200ms

package main
import (
	"fmt"
	"runtime"
)
func main() {
	var memStats runtime.MemStats
	// GC統計情報を取得
	runtime.ReadMemStats(&memStats)
	fmt.Printf("GC回数: %d\n", memStats.NumGC)
}

GC回数: 3

package main
import (
	"fmt"
	"os"
)
func main() {
	// GOGCの設定値を取得し、表示します
	goGcSetting := os.Getenv("GOGC")
	if goGcSetting == "" {
		fmt.Println("GOGCは未設定です")
	} else {
		fmt.Printf("GOGCの設定値: %s\n", goGcSetting)
	}
}

GOGCの設定値: 100

package main
import (
	"fmt"
	"time"
)
// unoptimizedProcessは最適化前の処理を模擬します。
func unoptimizedProcess(n int) int {
	result := 0
	for i := 0; i < n; i++ {
		result += i
	}
	return result
}
// optimizedProcessは数式を利用して高速化された処理を模擬します。
func optimizedProcess(n int) int {
	return n * (n - 1) / 2
}
func main() {
	const iterations = 10000000
	startUnoptimized := time.Now()
	resultUnoptimized := unoptimizedProcess(iterations)
	durationUnoptimized := time.Since(startUnoptimized)
	startOptimized := time.Now()
	resultOptimized := optimizedProcess(iterations)
	durationOptimized := time.Since(startOptimized)
	fmt.Printf("最適化前: result = %d, duration = %v\n", resultUnoptimized, durationUnoptimized)
	fmt.Printf("最適化後: result = %d, duration = %v\n", resultOptimized, durationOptimized)
}

最適化前: result = 49999995000000, duration = 150ms
最適化後: result = 49999995000000, duration = 10µs

package main
import (
	"fmt"
	"runtime"
)
func main() {
	fmt.Printf("OS: %s\n", runtime.GOOS)
	fmt.Printf("アーキテクチャ: %s\n", runtime.GOARCH)
	fmt.Printf("利用可能なCPUコア数: %d\n", runtime.NumCPU())
}

OS: linux
アーキテクチャ: amd64
利用可能なCPUコア数: 8