Go's garbage collection (GC) is automatic, using a concurrent three-color mark removal algorithm, implements concurrent collection through a write barrier, optimizes short-life cycle object recycling, and maintains low pause time. Developers can improve performance through object reuse and avoids memory leaks. 1. GC marks accessible objects from the root object and clears unreachable objects. 2. Write barriers ensure that reference updates are not missed during concurrency. 3. Although there is no explicit generational division, it is optimized according to "most objects die prematurely", and short-cycle GC is frequently executed. 4. Only submillisecond pauses are generated at the beginning and end of the mark to ensure low latency. 5. Developers can use sync.Pool to reuse objects to reduce allocation pressure and avoid memory problems caused by long-term holding of large objects or global references. Go's GC runs efficiently in the background, balancing memory and CPU overhead, and is suitable for modern applications.

Garbage collection (GC) in Go is automatic and designed to simplify memory management for developers. Unlike languages like C or C , where you manually allocate and free memory, Go handles this for you by reclaiming memory that's no longer in use. Here's how it works in a practical, real-world sense.

1. Tracing Garbage Collector (Mark-and-Sweep)

Go uses a concurrent, tri-color mark-and-sweep garbage collector. This means it traces through your program's memory, starting from "root" objects (like global variables and stack variables), and marks everything that's still reachable. Anything not marked is considered garbage and gets cleaned up.

The process has two main phases:

• Mark phase : The GC walks through all reachable objects and marks them as "in use."
• Sweep phase : It goes through unmarked memory regions and reclaims them for future allocations.

Because it's concurrent , the garbage collector runs alongside your program (the "mutator"), minimizing pauses. This is a big deal for low-latency applications.

2. Write Barriers Enable Concurrent Collection

One key to making GC concurrent is the use of write barriers . When your program updates a pointer (eg, obj.field = newObj ), a small piece of code (the write barrier) runs first to inform the GC about the change.

This ensures the GC doesn't miss references created while it's running. Without write barriers, the GC might incorrectly collect an object that was just referenced. They add a tiny overhead but allow the program to keep running without stopping for long GC pauses.

3. General Assumptions (Not Explicit, But Optimized)

Go doesn't have a traditional generational GC like Java (with young/old generations), but it's optimized around the same idea: most objects die young .

The Go GC focuses on efficiency by:

• Prioritizing fast allocation (using a bump allocator in thread-local caches).
• Running frequently, short GC cycles to clean up short-lived objects quickly.
• Tuning GC frequency based on heap growth (controlled via GOGC ).

GOGC=100 means GC runs when heap memory doubles. You can adjust this to trade memory for CPU usage.

4. Low Pause Times via Concurrency

Modern Go GC is optimized for low-latency . Most of the marking happens while your program runs. Only brief stop-the-world (STW) pauses occur:

• At the start of marking (to set up the process).
• At the end (to finalize marking).

These pauses are typically in the sub-millisecond range, making Go suitable for latency-sensitive services.

Tips for Developers

Even though GC is automatic, you can influence performance:

• Avoid holding references to large objects longer than needed.
• Reuse objects via pools ( sync.Pool ) for high-frequency allocations.
• Be mindful of memory leaks from global slices/maps or goroutines holding references.

 // Example: sync.Pool to reduce allocation pressure
var bufferPool = sync.Pool{
    New: func() interface{} { return new(bytes.Buffer) },
}

buf := bufferPool.Get().(*bytes.Buffer)
// use buf
bufferPool.Put(buf)

Basically, Go's GC works quietly in the background, using smart concurrency and tracing to keep your app running smoothly with minimal pauses. It's not magic, but it's well-tuned for modern applications.

The above is the detailed content of How does garbage collection work in Golang?. For more information, please follow other related articles on the PHP Chinese website!