Go言語でメモリ節約を実現する方法を解説

package main
import "fmt"
// main関数からプログラムが実行される
func main() {
	// 数値の変数 number を定義
	var number int = 100
	// 文字列型の変数 text を短縮宣言で定義
	text := "サンプルテキスト"
	fmt.Println("Number:", number)
	fmt.Println("Text:", text)
}

Number: 100
Text: サンプルテキスト

package main
import "fmt"
// main関数からプログラムが実行される
func main() {
	// 初期要素を持つスライス
	numbers := []int{1, 2, 3}
	fmt.Println("Slice:", numbers)
	// キーが文字列、値が整数のマップ
	fruits := map[string]int{"apple": 5, "banana": 3}
	fmt.Println("Map:", fruits)
}

Slice: [1 2 3]
Map: map[apple:5 banana:3]

package main
import (
	"fmt"
	"runtime"
)
// シンプルなメモリ使用量の測定関数
func printMemUsage() {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	// \( Alloc \) は現在割り当てられているメモリ量(バイト単位)
	fmt.Printf("Allocated: %v MiB\n", m.Alloc/1024/1024)
}
func main() {
	printMemUsage()
}

Allocated: 2 MiB

package main
import (
	"fmt"
	"os"
)
func main() {
	// GOGC環境変数の設定例(GC実行トリガーを調整)
	os.Setenv("GOGC", "100")
	fmt.Println("GOGC:", os.Getenv("GOGC"))
}

GOGC: 100

package main
import "fmt"
// Person構造体は人物情報を表す
type Person struct {
	Name string // 名前
	Age  int    // 年齢
}
func main() {
	// ポインタを使って構造体を生成し、コピーコストを削減
	personPtr := &Person{Name: "太郎", Age: 30}
	fmt.Printf("Name: %s, Age: %d\n", personPtr.Name, personPtr.Age)
}

Name: 太郎, Age: 30

package main
import "fmt"
func main() {
	// 初期容量を1024に設定したスライスを生成
	data := make([]byte, 0, 1024)
	fmt.Println("Capacity:", cap(data))
}

Capacity: 1024

package main
import (
	"fmt"
	"sync"
)
func main() {
	// sync.Poolを定義してオブジェクトの生成方法を指定
	pool := sync.Pool{
		New: func() interface{} {
			// 初期値として「初期値」の文字列が入ったバイトスライスを返す
			return []byte("初期値")
		},
	}
	// プールからオブジェクトを取得
	obj := pool.Get().([]byte)
	fmt.Println("Before:", string(obj))
	// オブジェクトを書き換え、再利用のシミュレーションを実施
	obj = []byte("更新後データ")
	// 使用後にプールへ返却
	pool.Put(obj)
	// プールから再度オブジェクトを取得
	retrieved := pool.Get().([]byte)
	fmt.Println("After:", string(retrieved))
}

Before: 初期値
After: 更新後データ

package main
import "fmt"
// process関数は、受け取ったスライスの各要素を2倍にして返す
func process(data []int) []int {
	for i := range data {
		data[i] *= 2
	}
	return data
}
func main() {
	input := []int{1, 2, 3, 4}
	result := process(input)
	fmt.Println("Result:", result)
}

Result: [2 4 6 8]

package main
import (
	"fmt"
	"os"
)
func main() {
	// 環境変数GOGCの現在の設定値を出力する
	currentGOGC := os.Getenv("GOGC")
	fmt.Println("Current GOGC:", currentGOGC)
}

Current GOGC: 100

package main
import (
	"fmt"
	"runtime/debug"
)
func main() {
	// GCの閾値を150%に設定する例(デフォルトは100%)
	debug.SetGCPercent(150)
	fmt.Println("Custom GCPercent set to 150")
}

Custom GCPercent set to 150

package main
import (
	"fmt"
	"log"
	"net/http"
	_ "net/http/pprof" // pprofを有効化するためのインポート
)
func main() {
	// pprof用のHTTPサーバを6060ポートで起動
	fmt.Println("pprof server starting at :6060")
	log.Fatal(http.ListenAndServe(":6060", nil))
}

pprof server starting at :6060

package main
import (
	"fmt"
	"runtime"
)
func main() {
	var memStats runtime.MemStats
	runtime.ReadMemStats(&memStats)
	// AllocおよびTotalAllocはそれぞれ現在の割り当て量と累積割り当て量(MiB換算)
	fmt.Printf("Alloc = %v MiB, TotalAlloc = %v MiB\n",
		memStats.Alloc/1024/1024, memStats.TotalAlloc/1024/1024)
}

Alloc = 2 MiB, TotalAlloc = 10 MiB

package main
import (
	"fmt"
	"runtime"
)
// printStatsはヒープ領域の使用量を出力する
func printStats() {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	fmt.Printf("HeapAlloc = %v MiB\n", m.HeapAlloc/1024/1024)
}
func main() {
	printStats()
}

HeapAlloc = 2 MiB

package main
import (
	"fmt"
	"runtime"
)
func main() {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	target := 50 // 目標値を50 MiBとする例
	current := m.HeapAlloc / 1024 / 1024
	if current > uint64(target) {
		fmt.Printf("Current memory usage %d MiB exceeds target %d MiB\n", current, target)
	} else {
		fmt.Printf("Memory usage %d MiB is within the target\n", current)
	}
}

Current memory usage 55 MiB exceeds target 50 MiB

package main
import (
	"fmt"
	"runtime"
)
// measureMemoryはヒープ割り当て量をMiB単位で返す
func measureMemory() uint64 {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	return m.HeapAlloc / 1024 / 1024
}
func main() {
	before := measureMemory()
	// シミュレーションとして10 MiBのデータを割り当て
	dummy := make([]byte, 1024*1024*10)
	_ = dummy
	after := measureMemory()
	fmt.Printf("Before: %d MiB, After: %d MiB\n", before, after)
}

Before: 2 MiB, After: 12 MiB

package main
import (
	"fmt"
	"runtime"
)
// measureMemoryUsageはヒープ割り当て量をMiB単位で返す
func measureMemoryUsage() uint64 {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	return m.HeapAlloc / 1024 / 1024
}
func main() {
	memoryBefore := measureMemoryUsage()
	// 例として5 MiBのデータを処理し、最適化のシミュレーションを実施
	dummy := make([]byte, 1024*1024*5)
	_ = dummy
	memoryAfter := measureMemoryUsage()
	improvement := int(memoryBefore) - int(memoryAfter)
	fmt.Printf("Memory improvement: %d MiB (Before: %d MiB, After: %d MiB)\n", improvement, memoryBefore, memoryAfter)
}

Memory improvement: -3 MiB (Before: 8 MiB, After: 11 MiB)