JVM memory மற்றும் garbage collection எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

JVM **memory-ஐ தானாக நிர்வகிக்கிறது** — objects-ஐ ஒதுக்கி, அணுக முடியாதவற்றை **garbage collection (GC)** மூலம் விடுவித்து — எனவே நீங்கள் memory-ஐ கைமுறையாக விடுவிக்க வேண்டியதில்லை. memory regions மற்றும் GC behavior-ஐ புரிந்துகொள்வது செயல்திறனை tune செய்வதற்கும் memory சிக்கல்களைக் கண்டறிவதற்கும் முக்கியம். ## JVM memory regions ```text HEAP — where all OBJECTS live (shared across threads), GC operates here ├── Young Generation — new objects (most die young) │ ├── Eden — new allocations go here │ └── Survivor — objects that survived a young GC └── Old (Tenured) Gen — long-lived objects (promoted from young) STACK — per-thread; method frames, local variables, primitive locals, references Metaspace — class metadata (replaced PermGen in Java 8+) ``` Objects **heap**-இல் வாழ்கின்றன; local variables மற்றும் references per-thread **stacks**-இல் வாழ்கின்றன. GC heap-இல் கவனம் செலுத்துகிறது. ## generational hypothesis ```text Observation: MOST objects die young (short-lived). → GC splits the heap into generations and collects the young gen FREQUENTLY (cheap, fast) and the old gen RARELY (expensive). ``` ## GC எவ்வாறு செயல்படுகிறது: mark and sweep ```text 1. MARK — starting from GC roots (stack refs, static fields), mark all REACHABLE objects 2. SWEEP — reclaim memory of unmarked (unreachable) objects 3. COMPACT— (often) move survivors together to reduce fragmentation ``` ஒரு object எந்த GC root-இலிருந்தும் **அணுக முடியாது** ஆகும்போது அது garbage ஆகும். நீங்கள் அதை விடுவிப்பதில்லை — GC அதைக் கண்டுபிடித்து மீட்டெடுக்கிறது. ## Minor vs Major GC ```text Minor GC — collects the Young Generation; frequent, fast, short pause Major/Full GC — collects the Old Generation (and more); rarer, longer pause → long Full GC pauses ("stop-the-world") are a common performance concern ``` ## GC algorithms (workload-க்கு ஏற்ப தேர்வு செய்யவும்) ```text G1 GC (default, Java 9+) — balanced, predictable pause times, good general choice Parallel GC — max throughput (batch jobs), longer pauses acceptable ZGC / Shenandoah — very low pause times for large heaps (latency-sensitive apps) ``` ## Memory leaks இன்னும் நிகழ்கின்றன (GC இருந்தாலும்) ```java // ❌ a leak: a static collection that only grows keeps objects REACHABLE forever static List

JVM memory regions

generational hypothesis

GC எவ்வாறு செயல்படுகிறது: mark and sweep

Minor vs Major GC

GC algorithms (workload-க்கு ஏற்ப தேர்வு செய்யவும்)

Memory leaks இன்னும் நிகழ்கின்றன (GC இருந்தாலும்)

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