Java Garbage Collection Guide: Understanding and Tuning

# Serial GC Configuration
-XX:+UseSerialGC
-Xms2g
-Xmx2g

# Memory Generations
Young Generation:
  - Eden Space
  - Survivor Space 0
  - Survivor Space 1
Old Generation:
  - Tenured Space

# GC Process
1. Mark live objects
2. Copy surviving objects
3. Compact heap space

# Parallel GC Configuration
-XX:+UseParallelGC
-XX:ParallelGCThreads=4
-XX:MaxGCPauseMillis=200
-XX:GCTimeRatio=99

# Advanced Tuning
-XX:YoungGenerationSizeIncrement=20
-XX:TenuredGenerationSizeIncrement=20
-XX:AdaptiveSizeDecrementScaleFactor=4

# Monitoring
jstat -gcutil $pid 1000
jstat -gccause $pid 1000

# G1 GC Configuration
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:G1HeapRegionSize=16M
-XX:G1ReservePercent=10
-XX:InitiatingHeapOccupancyPercent=45

# Logging Configuration
-Xlog:gc*:file=gc.log:time,uptime:filecount=5,filesize=100m

# Advanced Settings
-XX:ConcGCThreads=4
-XX:ParallelGCThreads=8
-XX:G1MixedGCLiveThresholdPercent=90
-XX:G1HeapWastePercent=5

public class G1GCDemo {
    // Simulate object allocation patterns
    public void allocateObjects() {
        List objects = new ArrayList<>();
        Random random = new Random();
        
        while (true) {
            // Allocate objects of varying sizes
            int size = random.nextInt(1024 * 1024);
            objects.add(new byte[size]);
            
            // Remove some objects to trigger GC
            if (objects.size() > 100) {
                objects.subList(0, 50).clear();
            }
            
            // Sleep to control allocation rate
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }
    
    public static void main(String[] args) {
        // JVM arguments for monitoring
        // -XX:+UseG1GC
        // -XX:+PrintGCDetails
        // -XX:+PrintGCTimeStamps
        // -Xloggc:gc.log
        new G1GCDemo().allocateObjects();
    }
}

// Memory allocation example
public class MemoryManagement {
    // Large object allocation
    private static final int LARGE_OBJECT_SIZE = 1024 * 1024;
    
    public void demonstrateAllocation() {
        // Young generation allocation
        List youngObjects = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            youngObjects.add(new byte[1024]);
        }
        
        // Old generation promotion
        List oldObjects = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            oldObjects.add(new byte[LARGE_OBJECT_SIZE]);
            System.gc(); // Force GC for demonstration
        }
    }
    
    // Memory leak prevention
    public class ResourceManager implements AutoCloseable {
        private final List resources = new ArrayList<>();
        
        public void allocateResource() {
            resources.add(new byte[1024]);
        }
        
        @Override
        public void close() {
            resources.clear();
        }
    }
    
    public void properResourceManagement() {
        try (ResourceManager manager = new ResourceManager()) {
            manager.allocateResource();
            // Use resources
        }
    }
}

public class MemoryLeakExamples {
    // Common memory leak: Static collections
    private static final List