Boost Go Performance: 6 Proven Techniques for Faster, Leaner Apps

How can you effectively improve performance and reduce garbage collection in Go? This article shares practical tips.

1. Match GOMAXPROCS to Kubernetes CPU quota

The Go scheduler can create as many OS threads as there are CPU cores. When a Go application runs on a Kubernetes node, it may see many cores, but the container’s CPU limit is often much lower.

Using github.com/uber-go/automaxprocs aligns the number of Go threads with the CPU quota defined in the pod’s YAML.

Example: Application CPU limit (in k8s.yaml): 1 core Node core count: 64 Without automaxprocs, the Go scheduler would try to use 64 threads; with automaxprocs, it uses only one.

Observed improvements in practice:

~60% CPU usage

~30% memory usage

~30% response time

2. Sort struct fields to reduce memory

The order of fields in a struct directly affects its memory footprint due to alignment.

type testStruct struct {
    testBool1   bool   // 1 byte
    testFloat1  float64 // 8 bytes
    testBool2   bool   // 1 byte
    testFloat2  float64 // 8 bytes
}

Printing the size shows 32 bytes, not the expected 18, because of 64‑bit alignment.

func main() {
    a := testStruct{}
    fmt.Println(unsafe.Sizeof(a)) // 32 bytes
}

Reordering fields by size reduces padding:

type testStruct struct {
    testFloat1 float64 // 8 bytes
    testFloat2 float64 // 8 bytes
    testBool1  bool   // 1 byte
    testBool2  bool   // 1 byte
}

func main() {
    a := testStruct{}
    fmt.Println(unsafe.Sizeof(a)) // 24 bytes
}

Developers can also use the fieldalignment analysis tool ( golang.org/x/tools/go/analysis/passes/fieldalignment) to automate this.

3. Tuning garbage collection

Before Go 1.19, GC behavior was controlled via GOGC (or runtime/debug.SetGCPercent). Go 1.19 introduced GOMEMLIMIT, an environment variable that caps the total memory a Go process may allocate.

Setting GOMEMLIMIT helps keep memory usage in check while still using GOGC for periodic collection. Disabling GOGC entirely is possible but should be done only when the application’s memory limits are well understood.

4. Zero‑copy string ↔ byte conversion with unsafe

Converting between string and []byte normally copies data. Using the unsafe package, you can perform a zero‑copy conversion on Go 1.20+:

// Go 1.20 and newer
func StringToBytes(s string) []byte {
    return unsafe.Slice(unsafe.StringData(s), len(s))
}

func BytesToString(b []byte) string {
    return unsafe.String(unsafe.SliceData(b), len(b))
}

For older versions, similar techniques exist via StringHeader and SliceHeader. Use with caution: do not apply when the underlying data may change.

5. Use jsoniter instead of encoding/json

jsoniter

is a drop‑in replacement for the standard library’s encoding/json, offering better performance while remaining 100% compatible.

Benchmark results show noticeable speedups.

Switching is straightforward:

import "encoding/json"

json.Marshal(&data)
json.Unmarshal(input, &data)

import jsoniter "github.com/json-iterator/go"

var json = jsoniter.ConfigCompatibleWithStandardLibrary
json.Marshal(&data)
json.Unmarshal(input, &data)

6. Reduce heap allocations with sync.Pool

Object pools avoid repeated allocations by reusing instances. Using sync.Pool can dramatically cut GC pressure.

type Person struct {
    Name string
}

var pool = sync.Pool{
    New: func() any {
        fmt.Println("Creating a new instance")
        return &Person{}
    },
}

func main() {
    person := pool.Get().(*Person)
    fmt.Println("Get object from sync.Pool for the first time:", person)
    person.Name = "Mehmet"
    fmt.Println("Put the object back in the pool")
    pool.Put(person)
    fmt.Println("Get object from pool again:", pool.Get().(*Person))
    fmt.Println("Get object from pool again (new one will be created):", pool.Get().(*Person))
}

// Output:
// Creating a new instance
// Get object from sync.Pool for the first time: &{}
// Put the object back in the pool
// Get object from pool again: &{Mehmet}
// Creating a new instance
// Get object from pool again (new one will be created): &{}

Applying this pattern in the New Relic Go Agent reduced CPU usage by ~40% and memory usage by ~22%.

These six optimizations can help you build faster, more efficient Go services.