JAVA SENIOR DEVELOPER INTERVIEW NOTES (JVM / MEMORY / GC)

================================================

WHAT IS JVM?
================================================

JVM (Java Virtual Machine) is a runtime engine responsible for executing Java bytecode.
It provides platform independence by converting compiled Java bytecode into machine
instructions specific to the host operating system.

Key responsibilities:

Load Java classes
Verify bytecode
Execute bytecode
Manage memory
Provide garbage collection
Handle security

Flow:
Java Code (.java)
↓
Compiler (javac)
↓
Bytecode (.class)
↓
JVM executes bytecode

Important Point:
Because of JVM, Java follows "Write Once Run Anywhere".

================================================
2. EXPLAIN JVM ARCHITECTURE

Main JVM Components:

Class Loader Subsystem
Runtime Data Areas
Execution Engine
Native Interface
Native Libraries

Architecture Flow:

Class Loader
↓
Bytecode Verification
↓
Runtime Memory Areas
↓
Execution Engine
↓
Native Method Interface

Details:

Class Loader
Loads .class files into memory.

Runtime Data Areas
Stores program data such as objects, methods, and stack frames.

Execution Engine
Executes bytecode using interpreter or JIT compiler.

JNI
Allows Java to interact with native code like C/C++.

================================================
3. DIFFERENCE BETWEEN JVM, JRE, AND JDK

JVM
Java Virtual Machine responsible for executing Java bytecode.

JRE
Java Runtime Environment contains:

JVM
Java libraries
Used to run Java applications.

JDK
Java Development Kit contains:

JRE
Development tools

Example tools in JDK:
javac
javadoc
jar
jdb

Structure:

JDK
└── JRE
└── JVM

================================================
4. WHAT HAPPENS WHEN YOU RUN "java MyClass"

Step 1
JVM starts and loads the main class.

Step 2
ClassLoader loads required classes.

Step 3
Bytecode verification happens.

Step 4
Memory allocation occurs.

Step 5
main() method execution begins.

Execution Flow:

Program Start
↓
Class Loading
↓
Bytecode Verification
↓
Initialization
↓
Execution

================================================
5. WHAT ARE JVM COMPONENTS?

Main components:

Class Loader
Loads class files.

Runtime Data Areas
Stores memory structures.

Execution Engine
Runs bytecode.

JNI
Allows interaction with native libraries.

Native Libraries
External OS libraries.

================================================
6. WHAT IS CLASS LOADER?

ClassLoader loads Java class files into memory.

Responsibilities:

Load class file
Verify bytecode
Prepare memory
Resolve references
Initialize class

Process:

Loading
Linking
Initialization

================================================
7. TYPES OF CLASSLOADERS

Three types:

Bootstrap ClassLoader
Loads core Java classes.

Platform ClassLoader
Loads platform libraries.

Application ClassLoader
Loads application classes.

Hierarchy:

Bootstrap
↓
Platform
↓
Application

================================================
8. WHAT IS BOOTSTRAP CLASSLOADER?

Bootstrap ClassLoader is the root class loader.

Responsibilities:
Loads core Java libraries.

Examples:
java.lang.*
java.util.*
java.io.*

Location:
JDK/lib directory.

Written in native code (C/C++).

================================================
9. WHAT IS PLATFORM CLASSLOADER?

Platform ClassLoader loads platform specific modules.

Example packages:
java.sql
java.xml
java.management

Introduced after Java 9 module system.

================================================
10. WHAT IS APPLICATION CLASSLOADER?

Application ClassLoader loads application classes from classpath.

Example:

Classes inside project
Libraries in classpath
External jars

This loader loads the main class of application.

================================================
11. WHAT IS PARENT DELEGATION MODEL?

Class loaders follow a hierarchy.

When class is requested:

Step 1
Application ClassLoader checks parent.

Step 2
Parent checks its parent.

Step 3
Bootstrap tries to load first.

If not found → child loads class.

Purpose:

Security
Avoid duplicate classes
Ensure core classes loaded first.

================================================
12. WHAT ARE CLASS LOADING PHASES?

Three phases:

Loading
Linking
Initialization

Loading
ClassLoader loads bytecode.

Linking has 3 parts:

Verification
Preparation
Resolution

Initialization
Static variables initialized.

================================================
13. WHAT IS BYTECODE VERIFICATION?

JVM verifies bytecode before execution.

Checks include:

Type safety
Stack overflow prevention
Illegal memory access
Instruction validity

Purpose:

Prevent malicious code
Ensure program safety.

================================================
14. WHAT IS JIT COMPILER?

JIT (Just In Time) compiler improves performance.

Normal execution:

Bytecode
↓
Interpreter
↓
Machine Code

With JIT:

Frequently executed code compiled into machine code.

Advantages:

Faster execution
Runtime optimization
Improved performance.

================================================
15. WHAT IS HOTSPOT JVM?

HotSpot JVM is the most widely used JVM implementation.

Features:

JIT compilation
Adaptive optimization
Garbage collection
Performance monitoring

HotSpot detects frequently executed code called "Hot Spots".

These parts get optimized aggressively.

================================================
16. WHAT IS TIERED COMPILATION?

Tiered compilation combines:

Interpreter
Client compiler
Server compiler

Levels:

Level 0
Interpreter

Level 1
Simple compilation

Level 4
Highly optimized compilation

Benefit:
Better startup and runtime performance.

================================================
17. WHAT IS METHOD INLINING?

Method inlining replaces method calls with actual method code.

Example:

Before:

calculate()
{
return add(a,b)
}

After optimization:

calculate()
{
return a + b
}

Benefits:

Removes method call overhead
Improves performance.

================================================
18. WHAT IS JVM WARMUP?

JVM warmup refers to the initial period where JVM gathers runtime data.

During warmup:

Interpreter runs code
Hot spots detected
JIT compiles frequently used code

After warmup:
Performance becomes faster.

================================================
19. WHAT IS ADAPTIVE OPTIMIZATION?

JVM monitors program behavior at runtime.

Based on execution patterns JVM:

Optimizes frequently executed code
Applies method inlining
Applies loop unrolling

This dynamic optimization is called adaptive optimization.

================================================
20. WHAT IS CLASS METADATA?

Class metadata contains information about class structure.

Stored in Metaspace.

Includes:

Class name
Methods
Fields
Annotations
Constant pool

Before Java 8 this was stored in PermGen.
After Java 8 it moved to Metaspace.

================================================
END SECTION

================================================
SECTION 2: JVM MEMORY MANAGEMENT

WHAT ARE JVM MEMORY AREAS?

JVM divides memory into several runtime data areas.

Main JVM memory areas:

Heap
Stack
Metaspace
Program Counter (PC Register)
Native Method Stack

Explanation:

Heap
Stores objects and class instances.

Stack
Stores method calls and local variables.

Metaspace
Stores class metadata.

PC Register
Stores current instruction being executed.

Native Method Stack
Used for native code execution.

Memory Layout Example:

JVM Memory
├── Heap
├── Stack
├── Metaspace
├── PC Register
└── Native Stack

================================================
22. WHAT IS HEAP MEMORY?

Heap memory is the runtime data area where objects are allocated.

Whenever you create an object using "new", it is stored in heap memory.

Example:

User u = new User();

Here:

Reference "u" → stored in Stack
Object "User" → stored in Heap

Heap is shared among all threads.

Heap is divided into:

Young Generation
Old Generation

Young Generation contains:

Eden Space
Survivor Space S0
Survivor Space S1

================================================
23. WHAT IS STACK MEMORY?

Stack memory stores:

Method calls
Local variables
References to objects

Each thread has its own stack.

Example:

public void method(){
int a = 10;
}

Here:
Variable "a" is stored in stack.

Stack follows LIFO (Last In First Out).

Function call example:

main()
↓
methodA()
↓
methodB()

Each method creates a stack frame.

================================================
24. WHAT IS METASPACE?

Metaspace stores class metadata.

Metadata includes:

Class structure
Methods
Fields
Constant pool
Annotations

Before Java 8:

PermGen was used.

After Java 8:

PermGen was removed and replaced with Metaspace.

Major advantage:

Metaspace uses native memory and grows dynamically.

================================================
25. DIFFERENCE BETWEEN PERMGEN AND METASPACE

PermGen (Before Java 8)

Stored in JVM heap.
Fixed size.
Could cause OutOfMemoryError frequently.

Metaspace (Java 8+)

Stored in native memory.
Automatically expands.
Better memory management.

Comparison:

PermGen

Fixed size
Inside heap
Removed in Java 8

Metaspace

Dynamic size
Outside heap
Current implementation

================================================
26. WHAT IS PROGRAM COUNTER REGISTER?

PC Register stores the address of the current instruction being executed.

Each thread has its own PC register.

Example:

Instruction sequence:

Line 1
Line 2
Line 3

PC register keeps track of which instruction is being executed.

Purpose:

Supports thread execution.

================================================
27. WHAT IS NATIVE METHOD STACK?

Native Method Stack is used when Java calls native code.

Example:

Java calling C or C++ library.

Example method:

System.loadLibrary("nativeLib");

Native code runs using the native stack.

================================================
28. WHAT CAUSES STACKOVERFLOWERROR?

StackOverflowError occurs when stack memory exceeds its limit.

Common reasons:

Infinite recursion
Deep method calls

Example:

public void recursive(){
recursive();
}

This causes infinite recursion and stack overflow.

Stack memory size controlled by:

-Xss

Example:

-Xss512k

================================================
29. WHAT CAUSES OUTOFMEMORYERROR?

OutOfMemoryError occurs when JVM cannot allocate memory.

Common causes:

Heap full
Metaspace full
Too many threads
Memory leak

Example:

List list = new ArrayList();
while(true){
list.add(new Object());
}

This continuously creates objects causing heap overflow.

================================================
30. DIFFERENCE BETWEEN HEAP AND STACK

Heap

Stores objects
Shared among threads
Managed by Garbage Collector

Stack

Stores method calls
Thread specific
Automatically cleaned after method completion

Comparison:

Heap

Objects
Shared memory
GC managed

Stack

Method frames
Thread specific
Faster access

================================================
31. WHAT IS OBJECT ALLOCATION IN JVM?

Object allocation process:

Step 1
Memory requested from heap.

Step 2
Object created in Eden space.

Step 3
Reference stored in stack.

Example:

User user = new User();

Memory flow:

Stack → reference
Heap → object

Most objects are first created in Eden space.

================================================
32. WHAT IS THREAD LOCAL ALLOCATION BUFFER (TLAB)?

TLAB is a small private memory area inside Eden space.

Each thread gets its own TLAB.

Purpose:

Reduce thread contention.

Without TLAB:

Multiple threads compete for heap allocation.

With TLAB:

Each thread allocates objects locally.

This improves performance significantly.

================================================
33. WHAT IS ESCAPE ANALYSIS?

Escape analysis determines whether an object escapes a method.

Example:

public void test(){
User u = new User();
}

If object is used only inside method → JVM may allocate it in stack.

Benefits:

Reduce heap allocation
Improve performance
Reduce GC pressure

================================================
34. WHAT IS COMPRESSED OOPS?

OOPS = Ordinary Object Pointers.

Compressed OOPS reduces memory usage.

Normally:

Object reference = 8 bytes

With compressed OOPS:

Reference = 4 bytes

Benefits:

Reduced memory consumption
Better cache usage

Enabled automatically when heap < 32GB.

================================================
35. WHAT IS OFF HEAP MEMORY?

Off heap memory is memory allocated outside JVM heap.

Used for:

High performance applications
Large data processing

Example technologies:

ByteBuffer
Netty
Apache Kafka

Benefits:

Reduce GC overhead.

================================================
36. WHAT IS DIRECT MEMORY?

Direct memory is a type of off heap memory used by NIO.

Example:

ByteBuffer buffer = ByteBuffer.allocateDirect(1024);

Advantages:

Faster IO operations.

Used in:

Network applications
High throughput systems.

================================================
37. WHAT JVM FLAGS CONTROL MEMORY?

Important JVM flags:

-Xms
Initial heap size

-Xmx
Maximum heap size

-XX:MaxMetaspaceSize
Maximum metaspace

-Xss
Stack size per thread

Example:

java -Xms2g -Xmx4g MyApp

================================================
38. WHAT IS -XMS?

-Xms defines the initial heap size.

Example:

-Xms2g

This allocates 2GB heap when JVM starts.

Setting equal Xms and Xmx reduces heap resizing overhead.

================================================
39. WHAT IS -XMX?

-Xmx defines the maximum heap size.

Example:

-Xmx4g

Heap cannot grow beyond this limit.

================================================
40. WHAT HAPPENS WHEN HEAP IS FULL?

When heap becomes full:

Step 1
Garbage collection triggered.

Step 2
Unused objects removed.

Step 3
If memory still insufficient:

OutOfMemoryError occurs.

Example error:

java.lang.OutOfMemoryError: Java heap space

================================================
END SECTION

================================================
SECTION 3: GARBAGE COLLECTION DEEP DIVE

WHAT IS MEMORY FRAGMENTATION?
Memory fragmentation occurs when free memory is broken into small non-contiguous blocks, making it hard to allocate large objects even if total free memory is sufficient.

Types:

Internal fragmentation: wasted space within allocated blocks
External fragmentation: free memory scattered in small chunks

WHAT IS EDEN SPACE?
Eden space is part of the Young Generation in the heap.

New objects are initially allocated here.
When Eden fills up → Minor GC occurs.

Example:

User user = new User(); // allocated in Eden

WHAT ARE SURVIVOR SPACES?
Young Generation has two survivor spaces (S0 and S1).

After Minor GC, live objects from Eden are moved to a survivor space.
Survivor spaces alternate in each GC cycle.

Purpose:

Reduce copying to old generation
Track object age for promotion

WHAT IS OLD GENERATION?
Old Generation (Tenured) stores long-lived objects.

Objects surviving multiple Minor GCs get promoted here.
GC in Old Generation = Major GC / Full GC

WHAT IS OBJECT PROMOTION?
Object promotion is moving objects from Young Generation to Old Generation.

Typically occurs after surviving a certain number of GC cycles (threshold age).
Helps optimize GC by segregating short-lived and long-lived objects.

WHAT IS MINOR GC?
Minor GC occurs in the Young Generation.

Only Eden + one Survivor Space is scanned.
Fast and frequent.
Can cause short Stop-The-World pause.

WHAT IS MAJOR GC / FULL GC?
Major/Full GC scans the Old Generation (and optionally Young Generation).

Slower than Minor GC.
Can trigger Stop-The-World pause.

WHAT IS GC ROOTS?
GC Roots are references used as starting points for garbage collection.

Objects reachable from GC roots are not collected.

Examples of GC roots:

Local variables in stack
Static fields
Active threads
JNI references

WHAT IS MARK AND SWEEP ALGORITHM?
Classic GC algorithm:
Mark: Traverse object graph from GC roots, mark reachable objects.
Sweep: Collect unmarked objects and free memory.

Characteristics:

Can cause fragmentation
Stop-the-World pause occurs

WHAT IS MARK-COMPACT ALGORITHM?
Improvement over Mark-Sweep:
Mark reachable objects
Compact live objects to reduce fragmentation

Benefits:

Less fragmentation
Objects moved together in memory

WHAT IS COPYING GC?
Copying GC divides memory into two halves:

Copy live objects from one half to the other
Clears entire source half

Used in Young Generation because most objects die quickly.

Advantages:

Fast allocation
Reduces fragmentation

WHAT IS STOP-THE-WORLD PAUSE?
Stop-the-World is when JVM halts application threads to perform GC.

During this pause:

All threads stop
GC performs mark, sweep, or compact
Application resumes after GC

WHAT IS GC OVERHEAD LIMIT EXCEEDED?
Occurs when GC spends too much time trying to free memory but cannot.

Typically > 98% of time spent in GC and < 2% memory reclaimed.
JVM throws: java.lang.OutOfMemoryError: GC overhead limit exceeded

WHAT TRIGGERS GC?
GC is triggered when:

Heap is full
Explicit call: System.gc() (suggestive only)
JVM heuristics for allocation

WHAT IS GENERATIONAL GC?
Divides heap into generations:

Young Generation: short-lived objects
Old Generation: long-lived objects

Benefits:

Minor GC fast
Old generation collected less frequently
Optimized for typical object lifespan

WHAT IS PROMOTION THRESHOLD?
Promotion threshold is the number of GC cycles an object must survive before moving from Young to Old Generation.

Example:

Threshold = 15
Object survives 15 Minor GCs → promoted to Old Gen

WHAT IS GC PAUSE TIME?
GC pause time = duration application threads are stopped for GC.

Influenced by heap size, GC algorithm, number of live objects
Target for low-latency applications: < 10 ms

WHAT IS GC THROUGHPUT?
GC throughput = percentage of total time not spent in GC.

Formula:

Throughput = (Total time - GC time) / Total time * 100%

Higher throughput → better application performance

WHAT IS SERIAL GC?

Single-threaded GC
Designed for single CPU or small heaps
Uses Mark-Sweep-Compact for Old Gen and Copying for Young Gen

Flags:

-XX:+UseSerialGC

WHAT IS PARALLEL GC?

Multi-threaded GC
Minor GC and Major GC use multiple threads
Default for Java 8 for server-class machines

Flags:

-XX:+UseParallelGC

WHAT IS CMS GC?
Concurrent Mark Sweep (CMS):

Old Gen GC with minimal pause
Phases:
1. Initial Mark
2. Concurrent Mark
3. Remark
4. Concurrent Sweep
Deprecated in Java 9+, removed later

WHAT IS G1 GC?
Garbage First GC (default in Java 11+)

Heap divided into regions (1–32MB)
Concurrent marking of regions
Evacuates regions with most garbage first
Predictable pause time

Flags:

-XX:+UseG1GC

WHAT IS ZGC?

Scalable low-latency GC
Supports heaps > 100GB
Pause times < 10ms
Concurrent compaction
Introduced in Java 11

Flags:

-XX:+UseZGC

WHAT IS SHENANDOAH GC?

Low-pause concurrent GC
Reduces pause times by performing compaction concurrently
Introduced by RedHat, integrated in Java 12+
Suitable for large heaps

Flags:

-XX:+UseShenandoahGC

WHEN TO USE G1 GC VS ZGC?

G1 GC: General purpose, moderate latency, default
ZGC: Very low pause times, extremely large heaps
Consider ZGC for large-memory, latency-sensitive apps

WHAT IS CONCURRENT GC?

GC runs in parallel with application threads
Reduces Stop-the-World pauses
Examples: CMS, G1, ZGC, Shenandoah

WHAT IS INCREMENTAL GC?

GC is performed in small steps instead of all at once
Reduces pause time
Often used in embedded or real-time systems

WHAT IS GC LOG ANALYSIS?

Analyzing GC logs helps:
- Identify frequent GCs
- Detect memory leaks
- Tune heap sizes and GC algorithms

Example JVM flag:

-Xlog:gc*:file=gc.log:time,uptime,level,tags

HOW TO ANALYZE HEAP DUMP?
Steps:
Generate heap dump:

jmap -dump:live,format=b,file=heap.hprof <pid>

Open in Eclipse MAT
Look for dominator tree, largest objects
Identify potential memory leaks
WHAT IS OBJECT LIFECYCLE IN JVM?
Allocation (usually in Eden)
Minor GC → surviving objects moved to survivor space
Promotion to Old Generation after multiple cycles
Major/Full GC → objects not reachable are removed
Memory reclaimed and reusable

================================================
END SECTION

================================================
SECTION 4: ADVANCED GC AND PRODUCTION DEBUGGING

HOW DOES G1 GC WORK INTERNALLY?

Heap divided into regions (1–32MB each)
Young + Old regions scattered
Steps:
1. Evacuation: Move objects from regions with most garbage
2. Concurrent marking: Identify live objects
3. Full GC fallback: If regions fragmented
Goal: predictable pause times
Default in Java 11+

WHAT ARE G1 GC PAUSE PREDICTIONS?

G1 targets user-defined pause times (e.g., -XX:MaxGCPauseMillis=200)
JVM calculates how many regions to collect to meet target
Uses heuristics to balance throughput and latency

WHAT IS G1 OLD GENERATION COLLECTION?

Old Generation is collected incrementally by evacuating regions
Reduces full GC pause
Unlike CMS, compaction is concurrent

WHAT IS G1 HUMONGOUS OBJECT?

Object > 50% of G1 region size
Allocated directly in contiguous regions
Treated as separate large region collection

HOW DOES ZGC REDUCE PAUSE TIMES?

Uses colored pointers for object relocation
All heap compaction done concurrently
Pause times <10ms even with 100GB+ heaps
Suitable for latency-sensitive systems

HOW DOES SHENANDOAH GC WORK?

Performs concurrent compaction
Relocates objects while application runs
Reduces Stop-the-World events
Tracks references with Brooks pointers
Ideal for large heaps (>32GB)

DIFFERENCE BETWEEN G1, ZGC, SHENANDOAH
| Feature | G1 | ZGC | Shenandoah |
|---------|----|-----|------------|
| Pause Time | Predictable | <10ms | Low |
| Heap Size | Moderate | Very large | Large |
| Compaction | Concurrent + STW | Concurrent | Concurrent |
| Default Java Version | 11+ | 11+ | 12+ |
WHAT IS CMS GC INTERNALS?

Uses concurrent mark-sweep
Phases:
1. Initial Mark (STW)
2. Concurrent Mark
3. Remark (STW)
4. Concurrent Sweep
Minimizes pause but may have fragmentation

HOW TO CHOOSE GC FOR MICROSERVICES?

Prioritize low-latency GC (ZGC/Shenandoah)
Avoid frequent full GCs
Monitor heap usage
Example flags: -XX:+UseG1GC -XX:MaxGCPauseMillis=200

WHAT IS GC LOGGING IN JAVA 8/11/17?

Java 8:

-XX:+PrintGCDetails -XX:+PrintGCDateStamps -Xloggc:gc.log

Java 9+:

-Xlog:gc*:file=gc.log:time,uptime,level,tags

HOW TO ANALYZE GC LOGS?

Identify frequent minor/major GCs
Analyze pause times
Check heap occupancy before/after GC
Tools: GCEasy, GCViewer, JClarity Censum

WHAT IS THREAD DUMP?

Snapshot of all thread states
Includes:
- Thread name
- State (RUNNABLE, BLOCKED, WAITING)
- Stack trace
Generated using:
- jstack <pid>
- Kill -3 (Linux)

HOW TO ANALYZE THREAD DUMP?

Look for blocked threads
Identify deadlocks
Check thread count
Example: Identify thread stuck on synchronized lock

WHAT IS DEADLOCK?

Two or more threads waiting for each other indefinitely
Example:

Thread A locks X, waits Y
Thread B locks Y, waits X

WHAT IS LIVELOCK?

Threads active but cannot make progress
Often due to retries or improper synchronization

WHAT IS THREAD STARVATION?

Thread waits indefinitely for CPU or lock
Happens with low-priority threads or unfair locks

WHAT IS BLOCKING QUEUE IN JAVA?

Thread-safe queue for producer-consumer scenarios
Blocks producers when full, consumers when empty
Classes:
- ArrayBlockingQueue
- LinkedBlockingQueue

HOW TO DEBUG HIGH CPU USAGE?

Generate thread dump
Analyze RUNNABLE threads
Identify tight loops or blocking code
Profilers: JVisualVM, Mission Control, YourKit

HOW TO DETECT MEMORY LEAKS?

Monitor heap usage over time
Use heap dump analysis
Identify objects retained unnecessarily
Example: static collections not cleared

WHAT TOOLS ARE USED FOR MEMORY ANALYSIS?

Eclipse MAT
VisualVM
JProfiler
YourKit

HOW TO GENERATE HEAP DUMP IN PRODUCTION?

Using JVM flags:

-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heap.hprof

WHAT IS DOMINATOR TREE?

In heap dump analysis
Shows which object is retaining most memory
Helps find memory leaks

HOW TO DEBUG OUTOFMEMORYERROR?

Analyze heap dump
Check which objects occupy heap
Adjust heap size if needed
Review GC logs

WHAT IS GC PAUSE INVESTIGATION?

Identify long GC pauses
Check heap occupancy, promotion rate
Tune GC algorithm or region sizes

WHAT IS SLOW THREAD DEBUGGING?

Identify threads stuck in RUNNABLE/WAITING
Check for I/O bottlenecks, locks, or infinite loops

WHAT IS PROFILING IN JAVA?

Measures CPU, memory, thread usage
Detects bottlenecks
Tools:
- YourKit
- VisualVM
- JProfiler

WHAT IS APPLICATION MONITORING?

Track metrics:
- Heap usage
- Thread count
- GC frequency
- Response time
Tools: Prometheus, Grafana, JMX

WHAT IS CPU SPIKE ANALYSIS?

Capture thread dump during spike
Identify busy threads
Use profilers for hotspot methods

WHAT IS MEMORY LEAK IN JAVA?

Objects retained unnecessarily
Cannot be garbage collected
Causes OutOfMemoryError over time

HOW TO PREVENT MEMORY LEAKS?

Avoid static collections holding objects
Close streams, connections
Weak references for caches
Use profiling tools regularly

WHAT IS PRODUCTION DEBUGGING FLOW?
Collect thread dumps
Collect heap dumps
Analyze GC logs
Identify bottlenecks
Apply fixes in code or tuning
WHAT IS GC TUNING?

Adjust heap sizes: -Xms, -Xmx
Choose proper GC: G1, ZGC, Shenandoah
Set pause targets: -XX:MaxGCPauseMillis
Tune region size: -XX:G1HeapRegionSize

WHAT IS STOP-THE-WORLD VS CONCURRENT GC?

Stop-the-world: All threads paused
Concurrent GC: GC works alongside application threads
Concurrent GC reduces latency

HOW TO HANDLE HUNG THREADS?

Use timeout mechanisms
Thread pool monitoring
Kill or restart hung threads

HOW TO ANALYZE THREAD CONTENTION?

Thread dump: BLOCKED or WAITING threads
Lock contention: synchronized blocks or ReentrantLock
Thread dump tools: VisualVM, Mission Control

HOW TO DEBUG APPLICATION HANGS?

Thread dump analysis
Check I/O or network waits
Check thread pool exhaustion
Review deadlocks or livelocks

WHAT IS HEAP DUMP ANALYSIS BEST PRACTICE?

Generate when memory usage is high
Use dominator tree
Identify top memory consumers
Cross-reference GC logs

HOW TO IDENTIFY LEAKING STATIC REFERENCES?

Check static collections in heap dump
Weak references may help
Remove unused objects

HOW TO DETECT LARGE OBJECTS IN HEAP?

Use Eclipse MAT → Histogram → Sort by size
Identify humongous objects
Optimize or split objects

HOW TO OPTIMIZE THREAD POOLS?

Right-size pool according to CPU and IO
Monitor queue length
Avoid unbounded thread pools

WHAT IS JVM MONITORING?

Metrics collection for production
Examples:
- GC frequency
- Thread usage
- Heap memory
Tools: JMX, VisualVM, Prometheus

HOW TO DEBUG MULTITHREADING ISSUES?

Thread dump analysis
Detect deadlocks, livelocks, starvation
Monitor thread pool usage
Use synchronized/locks properly

WHAT IS OFF-HEAP MEMORY TROUBLESHOOTING?

Identify ByteBuffer allocations
Check native memory usage
Tune DirectByteBuffer deallocation

WHAT IS LARGE HEAP TUNING STRATEGY?

Use concurrent low-latency GC
Monitor GC pause and frequency
Consider ZGC or Shenandoah for >32GB heaps

HOW TO DEBUG NATIVE MEMORY LEAKS?

Use tools like Native Memory Tracking (NMT)
Check JNI calls
Monitor memory outside heap

HOW TO DEBUG GC FREQUENCY ISSUES?

Excessive minor GC: reduce allocation rate, increase Eden
Excessive full GC: check old gen usage, tune promotion threshold

HOW TO IDENTIFY LONG-LIVED OBJECTS?

Use heap dump → dominator tree
Look for objects surviving multiple GCs
Consider caching strategy or object pool

HOW TO ANALYZE APPLICATION LATENCY?

Collect response times
Use profilers to identify slow methods
Check GC pauses impact

HOW TO HANDLE OUTOFHEAPERROR IN METASPACE?

Increase Metaspace size: -XX:MaxMetaspaceSize
Reduce number of loaded classes
Remove unnecessary class loading

BEST PRACTICES FOR JVM PERFORMANCE TUNING

Choose proper GC algorithm for workload
Tune heap sizes (-Xms = -Xmx for stability)
Use concurrent GCs for low-latency
Monitor GC logs and thread dumps
Profile memory and CPU regularly
Close resources properly (DB, streams, connections)
Use weak references for caches
Minimize object creation in hot paths
Use thread pools and avoid unbounded threads

================================================
END OF FILE

interviews

================================================2. EXPLAIN JVM ARCHITECTURE

================================================3. DIFFERENCE BETWEEN JVM, JRE, AND JDK

================================================4. WHAT HAPPENS WHEN YOU RUN "java MyClass"

================================================5. WHAT ARE JVM COMPONENTS?

================================================6. WHAT IS CLASS LOADER?

================================================7. TYPES OF CLASSLOADERS

================================================8. WHAT IS BOOTSTRAP CLASSLOADER?

================================================9. WHAT IS PLATFORM CLASSLOADER?

================================================10. WHAT IS APPLICATION CLASSLOADER?

================================================11. WHAT IS PARENT DELEGATION MODEL?

================================================12. WHAT ARE CLASS LOADING PHASES?

================================================13. WHAT IS BYTECODE VERIFICATION?

================================================14. WHAT IS JIT COMPILER?

================================================15. WHAT IS HOTSPOT JVM?

================================================16. WHAT IS TIERED COMPILATION?

================================================17. WHAT IS METHOD INLINING?

================================================18. WHAT IS JVM WARMUP?

================================================19. WHAT IS ADAPTIVE OPTIMIZATION?

================================================20. WHAT IS CLASS METADATA?

================================================END SECTION

================================================SECTION 2: JVM MEMORY MANAGEMENT

================================================END SECTION

================================================SECTION 3: GARBAGE COLLECTION DEEP DIVE

================================================END SECTION

================================================SECTION 4: ADVANCED GC AND PRODUCTION DEBUGGING

================================================END OF FILE

================================================
2. EXPLAIN JVM ARCHITECTURE

================================================
3. DIFFERENCE BETWEEN JVM, JRE, AND JDK

================================================
4. WHAT HAPPENS WHEN YOU RUN "java MyClass"

================================================
5. WHAT ARE JVM COMPONENTS?

================================================
6. WHAT IS CLASS LOADER?

================================================
7. TYPES OF CLASSLOADERS

================================================
8. WHAT IS BOOTSTRAP CLASSLOADER?

================================================
9. WHAT IS PLATFORM CLASSLOADER?

================================================
10. WHAT IS APPLICATION CLASSLOADER?

================================================
11. WHAT IS PARENT DELEGATION MODEL?

================================================
12. WHAT ARE CLASS LOADING PHASES?

================================================
13. WHAT IS BYTECODE VERIFICATION?

================================================
14. WHAT IS JIT COMPILER?

================================================
15. WHAT IS HOTSPOT JVM?

================================================
16. WHAT IS TIERED COMPILATION?

================================================
17. WHAT IS METHOD INLINING?

================================================
18. WHAT IS JVM WARMUP?

================================================
19. WHAT IS ADAPTIVE OPTIMIZATION?

================================================
20. WHAT IS CLASS METADATA?

================================================
END SECTION

================================================
SECTION 2: JVM MEMORY MANAGEMENT

================================================
END SECTION

================================================
SECTION 3: GARBAGE COLLECTION DEEP DIVE

================================================
END SECTION

================================================
SECTION 4: ADVANCED GC AND PRODUCTION DEBUGGING

================================================
END OF FILE