// Pre-container era assumptions
public class SystemInfo {
    public static void main(String[] args) {
        // These values ignore container limits!
        System.out.println("Available processors: " + 
            Runtime.getRuntime().availableProcessors());
        System.out.println("Max memory: " + 
            Runtime.getRuntime().maxMemory() / 1024 / 1024 + " MB");
        System.out.println("Total memory: " + 
            Runtime.getRuntime().totalMemory() / 1024 / 1024 + " MB");
    }
}

# Dockerfile with container-aware JVM settings
FROM eclipse-temurin:17-jre-alpine

# Enable container support (default in JDK 10+)
ENV JAVA_OPTS="-XX:+UseContainerSupport \
    -XX:MaxRAMPercentage=75.0 \
    -XX:InitialRAMPercentage=50.0 \
    -XX:MinRAMPercentage=50.0"

COPY target/app.jar /app.jar

ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar /app.jar"]

#!/bin/bash
# calculate_heap.sh - Container-aware heap calculation

CONTAINER_MEMORY_IN_BYTES=$(cat /sys/fs/cgroup/memory/memory.limit_in_bytes)
CONTAINER_MEMORY_IN_MB=$((CONTAINER_MEMORY_IN_BYTES / 1024 / 1024))

# Reserve memory for off-heap usage
RESERVED_MEMORY_MB=300  # Metaspace, thread stacks, native memory
HEAP_SIZE_MB=$((CONTAINER_MEMORY_IN_MB - RESERVED_MEMORY_MB))

# Apply percentage for safety margin
HEAP_SIZE_MB=$((HEAP_SIZE_MB * 75 / 100))

echo "-Xmx${HEAP_SIZE_MB}m -Xms${HEAP_SIZE_MB}m"

// JVM startup class with memory diagnostics
public class MemoryDiagnostics {
    public static void printMemoryInfo() {
        long maxHeap = Runtime.getRuntime().maxMemory();
        long totalHeap = Runtime.getRuntime().totalMemory();
        long freeHeap = Runtime.getRuntime().freeMemory();
        long usedHeap = totalHeap - freeHeap;
        
        System.out.println("=== JVM Memory Info ===");
        System.out.printf("Max Heap: %.2f MB%n", maxHeap / 1048576.0);
        System.out.printf("Total Heap: %.2f MB%n", totalHeap / 1048576.0);
        System.out.printf("Used Heap: %.2f MB%n", usedHeap / 1048576.0);
        System.out.printf("Free Heap: %.2f MB%n", freeHeap / 1048576.0);
        
        // Container limits
        long containerMemory = getContainerMemoryLimit();
        if (containerMemory > 0) {
            System.out.printf("Container Memory Limit: %.2f MB%n", 
                containerMemory / 1048576.0);
            System.out.printf("Heap to Container Ratio: %.2f%%%n", 
                (maxHeap * 100.0) / containerMemory);
        }
    }
    
    private static long getContainerMemoryLimit() {
        try {
            String memoryLimit = Files.readString(
                Paths.get("/sys/fs/cgroup/memory/memory.limit_in_bytes")
            ).trim();
            return Long.parseLong(memoryLimit);
        } catch (Exception e) {
            return -1;
        }
    }
}

# G1GC configuration for low-latency microservices
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:G1HeapRegionSize=16m
-XX:G1ReservePercent=10
-XX:InitiatingHeapOccupancyPercent=45
-XX:ConcGCThreads=2
-XX:ParallelGCThreads=4
-XX:+ParallelRefProcEnabled
-XX:+DisableExplicitGC
-XX:+UseStringDeduplication
-XX:+AlwaysPreTouch

# ZGC configuration (JDK 15+)
-XX:+UseZGC
-XX:ZCollectionInterval=30
-XX:ZAllocationSpikeTolerance=5
-XX:+ZProactive
-XX:ZFragmentationLimit=10

import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.util.List;

public class GCMonitor {
    private static class GCStats {
        long collectionCount;
        long collectionTime;
        
        GCStats(long count, long time) {
            this.collectionCount = count;
            this.collectionTime = time;
        }
    }
    
    private final Map<String, GCStats> previousStats = new HashMap<>();
    
    public void logGCMetrics() {
        List<GarbageCollectorMXBean> gcBeans = 
            ManagementFactory.getGarbageCollectorMXBeans();
        
        for (GarbageCollectorMXBean gcBean : gcBeans) {
            String name = gcBean.getName();
            long count = gcBean.getCollectionCount();
            long time = gcBean.getCollectionTime();
            
            GCStats prev = previousStats.get(name);
            if (prev != null) {
                long deltaCount = count - prev.collectionCount;
                long deltaTime = time - prev.collectionTime;
                
                if (deltaCount > 0) {
                    double avgTime = (double) deltaTime / deltaCount;
                    System.out.printf("GC %s: %d collections, %.2f ms avg%n",
                        name, deltaCount, avgTime);
                }
            }
            
            previousStats.put(name, new GCStats(count, time));
        }
    }
}

# Kubernetes deployment with CPU limits
apiVersion: apps/v1
kind: Deployment
metadata:
  name: java-microservice
spec:
  template:
    spec:
      containers:
      - name: app
        image: myapp:latest
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
        env:
        - name: JAVA_OPTS
          value: >-
            -XX:ActiveProcessorCount=1
            -XX:+UseContainerSupport
            -XX:MaxRAMPercentage=75.0
            -XX:+PreferContainerQuotaForCPUCount

import java.util.concurrent.*;

public class ContainerAwareThreadPool {
    private static final int MIN_THREADS = 2;
    private static final double CPU_UTILIZATION_TARGET = 0.8;
    private static final double WAIT_TIME_RATIO = 0.5; // I/O wait time
    
    public static ExecutorService createOptimalThreadPool() {
        int availableCores = getContainerCpuCount();
        int optimalThreads = calculateOptimalThreads(
            availableCores, 
            CPU_UTILIZATION_TARGET, 
            WAIT_TIME_RATIO
        );
        
        System.out.printf("Creating thread pool with %d threads for %d cores%n",
            optimalThreads, availableCores);
        
        return new ThreadPoolExecutor(
            optimalThreads / 2,  // Core pool size
            optimalThreads,      // Maximum pool size
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1000),
            new ThreadFactory() {
                private final AtomicInteger counter = new AtomicInteger();
                
                @Override
                public Thread newThread(Runnable r) {
                    Thread thread = new Thread(r);
                    thread.setName("worker-" + counter.incrementAndGet());
                    thread.setDaemon(true);
                    return thread;
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
    
    private static int getContainerCpuCount() {
        // Use container-aware processor count
        int processors = Runtime.getRuntime().availableProcessors();
        
        // Check if running in container with CPU limits
        try {
            String cpuQuota = Files.readString(
                Paths.get("/sys/fs/cgroup/cpu/cpu.cfs_quota_us")
            ).trim();
            String cpuPeriod = Files.readString(
                Paths.get("/sys/fs/cgroup/cpu/cpu.cfs_period_us")
            ).trim();
            
            if (!"-1".equals(cpuQuota)) {
                long quota = Long.parseLong(cpuQuota);
                long period = Long.parseLong(cpuPeriod);
                processors = (int) Math.ceil((double) quota / period);
            }
        } catch (Exception e) {
            // Fall back to runtime processor count
        }
        
        return Math.max(MIN_THREADS, processors);
    }
    
    private static int calculateOptimalThreads(int cores, 
                                              double targetUtilization, 
                                              double waitTimeRatio) {
        // Little's Law: N = λ * W
        // Optimal threads = cores * target_utilization * (1 + wait/compute)
        return (int) Math.ceil(cores * targetUtilization * (1 + waitTimeRatio));
    }
}

public class NativeMemoryTracker {
    public static void enableTracking() {
        // Add to JVM options: -XX:NativeMemoryTracking=summary
    }
    
    public static void printNativeMemoryReport() {
        try {
            ProcessBuilder pb = new ProcessBuilder(
                "jcmd", 
                String.valueOf(ProcessHandle.current().pid()), 
                "VM.native_memory", 
                "summary"
            );
            
            Process process = pb.start();
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(process.getInputStream()))) {
                reader.lines().forEach(System.out::println);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// Direct memory configuration
public class DirectMemoryConfig {
    static {
        // Set max direct memory size
        System.setProperty("sun.nio.MaxDirectMemorySize", "256m");
    }
    
    public static ByteBuffer allocateDirect(int capacity) {
        try {
            return ByteBuffer.allocateDirect(capacity);
        } catch (OutOfMemoryError e) {
            // Log direct memory usage
            logDirectMemoryUsage();
            throw e;
        }
    }
    
    private static void logDirectMemoryUsage() {
        long maxDirectMemory = VM.maxDirectMemory();
        long usedDirectMemory = getUsedDirectMemory();
        
        System.err.printf("Direct memory exhausted: %d/%d bytes used%n",
            usedDirectMemory, maxDirectMemory);
    }
}

@SpringBootApplication
@ComponentScan(lazyInit = true)
public class OptimizedSpringApp {
    public static void main(String[] args) {
        // Optimize startup time
        System.setProperty("spring.jmx.enabled", "false");
        System.setProperty("spring.config.location", "classpath:application.yml");
        System.setProperty("logging.level.root", "WARN");
        
        new SpringApplicationBuilder(OptimizedSpringApp.class)
            .web(WebApplicationType.REACTIVE) // Use reactive for better resource usage
            .lazyInitialization(true)
            .build()
            .run(args);
    }
}

@Configuration
@EnableConfigurationProperties
@ConditionalOnProperty(name = "app.features.cache", havingValue = "true")
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        // Use Caffeine for efficient memory usage
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .recordStats());
        return cacheManager;
    }
}

# Generate CDS archive
java -XX:DumpLoadedClassList=classes.lst \
     -XX:+UseContainerSupport \
     -jar app.jar

java -Xshare:dump \
     -XX:SharedClassListFile=classes.lst \
     -XX:SharedArchiveFile=app.jsa \
     -cp app.jar

# Use CDS archive for faster startup
java -XX:SharedArchiveFile=app.jsa \
     -XX:+UseContainerSupport \
     -jar app.jar

@Configuration
public class JMXConfig {
    @Bean
    public MBeanExporter mBeanExporter() {
        MBeanExporter exporter = new MBeanExporter();
        exporter.setAutodetect(true);
        return exporter;
    }
    
    @Bean
    @ManagedResource
    public JVMMetrics jvmMetrics() {
        return new JVMMetrics();
    }
}

@ManagedResource(objectName = "app:type=JVM,name=Metrics")
public class JVMMetrics {
    @ManagedAttribute
    public long getHeapUsed() {
        return ManagementFactory.getMemoryMXBean()
            .getHeapMemoryUsage().getUsed();
    }
    
    @ManagedAttribute
    public double getCpuUsage() {
        return ManagementFactory.getPlatformMXBean(
            com.sun.management.OperatingSystemMXBean.class
        ).getProcessCpuLoad();
    }
    
    @ManagedAttribute
    public long getThreadCount() {
        return ManagementFactory.getThreadMXBean().getThreadCount();
    }
}

@RestController
@RequestMapping("/metrics")
public class PrometheusMetricsEndpoint {
    private final CollectorRegistry registry = new CollectorRegistry();
    
    private final Gauge heapUsage = Gauge.build()
        .name("jvm_heap_used_bytes")
        .help("Used heap memory in bytes")
        .register(registry);
    
    private final Counter gcCount = Counter.build()
        .name("jvm_gc_collection_seconds_count")
        .help("GC collection count")
        .labelNames("gc_type")
        .register(registry);
    
    @GetMapping(produces = TextFormat.CONTENT_TYPE_004)
    public String metrics() {
        updateMetrics();
        
        StringWriter writer = new StringWriter();
        try {
            TextFormat.write004(writer, registry.metricFamilySamples());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return writer.toString();
    }
    
    private void updateMetrics() {
        // Update heap usage
        heapUsage.set(Runtime.getRuntime().totalMemory() - 
                     Runtime.getRuntime().freeMemory());
        
        // Update GC metrics
        for (GarbageCollectorMXBean gc : 
             ManagementFactory.getGarbageCollectorMXBeans()) {
            gcCount.labels(gc.getName()).inc(gc.getCollectionCount());
        }
    }
}

# Multi-stage build for minimal image
FROM maven:3.8-openjdk-17 AS builder
WORKDIR /build
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests

FROM eclipse-temurin:17-jre-alpine
RUN apk add --no-cache dumb-init

COPY --from=builder /build/target/app.jar /app.jar

ENTRYPOINT ["dumb-init", "java", \
    "-XX:+UseContainerSupport", \
    "-XX:MaxRAMPercentage=80.0", \
    "-XX:+UseG1GC", \
    "-XX:+UseStringDeduplication", \
    "-Djava.security.egd=file:/dev/./urandom", \
    "-jar", "/app.jar"]

# Kubernetes deployment for high-throughput service
apiVersion: v1
kind: ConfigMap
metadata:
  name: jvm-config
data:
  JAVA_OPTS: |
    -XX:+UseZGC
    -XX:MaxRAMPercentage=85.0
    -XX:ConcGCThreads=4
    -XX:+UseLargePages
    -XX:+AlwaysPreTouch
    -XX:+DisableExplicitGC
    -XX:+PerfDisableSharedMem
    -Djava.awt.headless=true
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: high-throughput-service
spec:
  replicas: 5
  template:
    spec:
      containers:
      - name: app
        image: myapp:latest
        resources:
          requests:
            memory: "4Gi"
            cpu: "2"
          limits:
            memory: "4Gi"
            cpu: "4"
        envFrom:
        - configMapRef:
            name: jvm-config