Go memory மற்றும் garbage collection-ஐ எவ்வாறு நிர்வகிக்கிறது?

Question

Accepted Answer

Go ஆனது garbage collector மூலம் memory-ஐ **தானாகவே நிர்வகிக்கிறது**, manual allocation/freeing-இலிருந்து உங்களை விடுவிக்கிறது. அதன் GC ஆனது pause times-ஐ குறைக்க வடிவமைக்கப்பட்ட **concurrent, low-latency, non-generational mark-and-sweep** collector ஆகும் — latency-sensitive services-க்கு Go பொருந்துவதற்கான ஒரு முக்கிய காரணம் இதுவே.

## Stack vs heap மற்றும் escape analysis

```go
// the compiler decides where each value lives via ESCAPE ANALYSIS
func noEscape() int {
    x := 42        // stays on the STACK — doesn't escape, freed when function returns (cheap)
    return x
}
func escapes() *int {
    x := 42        // ESCAPES to the HEAP — its pointer outlives the function (GC-managed)
    return &x
}
```

Go-வின் compiler ஆனது compile time-இல் **escape analysis** செய்கிறது: தங்கள் function-ஐ விட நீடிக்காத மதிப்புகள் மலிவான, தானாக-விடுவிக்கப்படும் **stack**-இல் இருக்கின்றன; references escape ஆகும் மதிப்புகள் **heap**-இல் (GC நிர்வகிக்கும் இடம்) செல்கின்றன. Stack allocation அடிப்படையில் இலவசம், எனவே heap escapes-ஐ குறைப்பது GC வேலையைக் குறைக்கிறது.

## Garbage collector: concurrent mark-and-sweep

```text
Go's GC characteristics:
  ✓ MARK-AND-SWEEP — marks reachable objects (from roots), sweeps the rest
  ✓ CONCURRENT — runs mostly alongside your program (not stop-the-world)
  ✓ LOW LATENCY — optimized for short pauses (typically sub-millisecond), not throughput
  ✓ NON-GENERATIONAL — unlike the JVM, treats all objects uniformly (simpler)
```

Go வேண்டுமென்றே throughput-ஐ விட **குறைந்த pause times**-க்கு முன்னுரிமை அளிக்கிறது — GC பெரும்பாலான வேலையை உங்கள் program-உடன் concurrent ஆக செய்கிறது, இதனால் "stop-the-world" pauses மிகவும் குறுகியதாக வைத்திருக்கிறது. இது latency-sensitive servers-க்கு Go-ஐ வலிமையாக்குகிறது.

## GC-ஐ tune செய்தல்

```bash
GOGC=100   # default: trigger GC when heap grows 100% since the last collection
           # higher GOGC → less frequent GC (more memory, less CPU)
           # lower GOGC → more frequent GC (less memory, more CPU)
GOMEMLIMIT=2GiB   # a soft memory limit (Go 1.19+) — GC works harder near it
```

## GC pressure-ஐ குறைத்தல் (performance technique)

```go
// 1. reuse objects with sync.Pool to reduce allocations
var bufPool = sync.Pool{New: func() any { return new(bytes.Buffer) }}
buf := bufPool.Get().(*bytes.Buffer)
defer bufPool.Put(buf)

// 2. preallocate slices with known capacity (avoid repeated growth/realloc)
data := make([]int, 0, 1000)

// 3. minimize heap escapes; avoid unnecessary pointers/allocations in hot loops
```

குறைவான allocations = குறைவான GC வேலை. `sync.Pool` (object reuse), preallocation, மற்றும் escapes-ஐ குறைத்தல் ஆகியவை hot paths-இல் GC pressure-ஐ குறைப்பதற்கான முக்கிய வழிகள்.

## Memory leaks இன்னும் நிகழ்கின்றன

```text
GC frees only UNREACHABLE objects. Leaks come from lingering REFERENCES:
  ✗ goroutine leaks (a blocked goroutine keeps its referenced memory alive)
  ✗ growing global maps/slices, unclosed resources, forgotten subscriptions
```

## இது ஏன் முக்கியம்

Go-வின் தானியங்கி memory நிர்வாகம் ஒரு பெரிய productivity மற்றும் safety வெற்றியாகும் (manual free இல்லை, dangling pointers இல்லை), ஆனால் அது *எப்படி* வேலை செய்கிறது என்பதைப் புரிந்துகொள்வது, performance-critical மற்றும் latency-sensitive applications-க்கு மதிப்புமிக்கது — இவற்றுக்காகவே Go அடிக்கடி தேர்ந்தெடுக்கப்படுகிறது.

முக்கிய நுண்ணறிவுகள்: **escape analysis** ஆனது stack vs heap allocation-ஐ தீர்மானிக்கிறது (stack இலவசம்; heap escapes-ஐ குறைப்பது GC வேலையைக் குறைக்கிறது), மேலும் Go-வின் **concurrent, low-latency GC** ஆனது throughput-ஐ விட குறுகிய pauses-க்கு முன்னுரிமை அளிக்கிறது (throughput-மையமான collectors போலன்றி, servers-க்கு ஏற்றது).

GC pressure-ஐ எவ்வாறு குறைப்பது (`sync.Pool`, preallocation, hot loops-இல் குறைவான allocations), அதை எவ்வாறு tune செய்வது (`GOGC`, `GOMEMLIMIT`), மற்றும் lingering references-இலிருந்து (குறிப்பாக goroutine leaks) **leaks இன்னும் நிகழ்கின்றன** என்பதை அங்கீகரிப்பது, high-performance Go services-ஐ இயக்குவதற்கு முக்கியமானது.

இது senior Go developers-ஐ வேறுபடுத்தும் ஆழமான, நடைமுறை அறிவாகும் மற்றும் performance-sensitive roles-க்கான ஒரு பொதுவான மேம்பட்ட interview தலைப்பாகும்.

Stack vs heap மற்றும் escape analysis

Garbage collector: concurrent mark-and-sweep

GC-ஐ tune செய்தல்

GC pressure-ஐ குறைத்தல் (performance technique)

Memory leaks இன்னும் நிகழ்கின்றன

இது ஏன் முக்கியம்

question.related