Production Performance Tuning

The difference between "works in dev" and "survives Black Friday" — real numbers, real formulas, real configs.

JVM Tuning for Spring Boot

Heap Sizing

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph Heap["JVM Heap"]
        Y["Young Gen<br/>(Eden + Survivor)"] -->|"promotion"| O["Old Gen<br/>(long-lived objects)"]
    end
    M["Metaspace<br/>(class metadata)"] -.->|"outside heap"| Heap

    style Y fill:#ECFDF5,stroke:#6EE7B7,color:#1E40AF
    style O fill:#FEF3C7,stroke:#FCD34D,color:#1E40AF
    style M fill:#EFF6FF,stroke:#DBEAFE,color:#1E40AF

# Container-aware JVM settings (Java 17+)
java -XX:+UseContainerSupport \
     -XX:MaxRAMPercentage=75.0 \
     -XX:InitialRAMPercentage=75.0 \
     -XX:+UseG1GC \
     -jar app.jar

GC Algorithm Selection

# For a typical REST API microservice (G1GC with tuning)
java -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=100 \
     -XX:G1HeapRegionSize=16m \
     -XX:+ParallelRefProcEnabled \
     -Xmx3g -Xms3g \
     -jar app.jar

# For low-latency service (ZGC — Java 21+)
java -XX:+UseZGC \
     -XX:+ZGenerational \
     -Xmx4g -Xms4g \
     -jar app.jar

Connection Pool Tuning (HikariCP)

The Golden Formula

pool_size = (core_count * 2) + effective_spindle_count

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    subgraph App["Application (20 Tomcat threads)"]
        T1["Thread 1"] & T2["Thread 2"] & T3["Thread ..."] & T4["Thread 20"]
    end

    subgraph Pool["HikariCP Pool (max=10)"]
        C1["Conn 1 (active)"] & C2["Conn 2 (active)"] & C3["Conn 3 (idle)"]
    end

    subgraph DB["PostgreSQL (max_connections=100)"]
        D1[("Connections")]
    end

    App -->|"borrow"| Pool
    Pool -->|"actual DB"| DB
    T1 -.->|"waiting..."| Pool

    style T1 fill:#FEE2E2,stroke:#FCA5A5,color:#1E40AF
    style C1 fill:#ECFDF5,stroke:#6EE7B7,color:#1E40AF
    style C2 fill:#ECFDF5,stroke:#6EE7B7,color:#1E40AF
    style C3 fill:#FEF3C7,stroke:#FCD34D,color:#1E40AF

Production Configuration

spring:
  datasource:
    hikari:
      # Pool sizing
      maximum-pool-size: 10          # max connections in pool
      minimum-idle: 5                # keep 5 ready connections
      # Timeouts
      connection-timeout: 30000      # fail fast if no connection in 30s
      idle-timeout: 600000           # close idle connections after 10min
      max-lifetime: 1800000          # recycle connections every 30min
      # Leak detection
      leak-detection-threshold: 60000  # warn if held > 60s
      # Validation
      connection-test-query: SELECT 1
      validation-timeout: 5000

Pool Sizing by Workload

Thread Pool Configuration

Tomcat Thread Pool

server:
  tomcat:
    threads:
      max: 200         # max worker threads (default: 200)
      min-spare: 25    # keep 25 threads ready
    max-connections: 8192  # max TCP connections queued
    accept-count: 100      # OS-level backlog queue
    connection-timeout: 20000  # close idle connections after 20s

Sizing Formula

Optimal threads = Number of CPUs * Target CPU utilization * (1 + Wait time / Service time)

Virtual Threads (Java 21+ / Spring Boot 3.2+)

# Enable virtual threads — replaces Tomcat thread pool with virtual threads
spring:
  threads:
    virtual:
      enabled: true

// Before: @Async with bounded thread pool
@Async("taskExecutor")
public CompletableFuture<Result> processAsync() { ... }

// After: Virtual threads — unbounded, lightweight, cheap to create
// No pool sizing needed — each request gets its own virtual thread

Startup Time Optimization

Benchmark Comparison

Configuration

# Lazy initialization — beans created on first use
spring:
  main:
    lazy-initialization: true

# Exclude auto-configurations you don't need
  autoconfigure:
    exclude:
      - org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration
      - org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration

# Class Data Sharing (CDS) — dump class list, then use archive
# Step 1: Generate class list
java -XX:DumpLoadedClassList=classes.lst -jar app.jar &
# Wait for startup, then kill

# Step 2: Create shared archive
java -Xshare:dump -XX:SharedClassListFile=classes.lst \
     -XX:SharedArchiveFile=app-cds.jsa -jar app.jar

# Step 3: Use archive on startup
java -Xshare:on -XX:SharedArchiveFile=app-cds.jsa -jar app.jar

Caching Strategy

Multi-Layer Cache Architecture

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    R(("Request")) --> L1{"L1: In-Process<br/>(Caffeine)"}
    L1 -->|"miss"| L2{"L2: Distributed<br/>(Redis)"}
    L2 -->|"miss"| DB[("Database")]
    DB -->|"populate L2"| L2
    L2 -->|"populate L1"| L1
    L1 -->|"hit (1μs)"| R
    L2 -->|"hit (1-3ms)"| R

    style L1 fill:#ECFDF5,stroke:#6EE7B7,color:#1E40AF
    style L2 fill:#FEF3C7,stroke:#FCD34D,color:#1E40AF
    style DB fill:#EFF6FF,stroke:#DBEAFE,color:#1E40AF

Caffeine Configuration (L1)

spring:
  cache:
    type: caffeine
    caffeine:
      spec: maximumSize=10000,expireAfterWrite=5m,recordStats

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager manager = new CaffeineCacheManager();
        manager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(Duration.ofMinutes(5))
            .recordStats());  // exposes hit/miss metrics
        return manager;
    }
}

When NOT to Cache

HTTP & Network Optimization

WebClient vs RestTemplate

// ✅ WebClient with connection pooling (non-blocking)
@Bean
public WebClient webClient() {
    HttpClient httpClient = HttpClient.create()
        .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
        .responseTimeout(Duration.ofSeconds(10))
        .doOnConnected(conn -> conn
            .addHandlerLast(new ReadTimeoutHandler(10))
            .addHandlerLast(new WriteTimeoutHandler(5)));

    return WebClient.builder()
        .clientConnector(new ReactorClientHttpConnector(httpClient))
        .build();
}

Response Compression

server:
  compression:
    enabled: true
    mime-types: application/json,application/xml,text/html,text/plain
    min-response-size: 1024  # only compress responses > 1KB

HTTP/2

server:
  http2:
    enabled: true  # multiplexing, header compression, server push

Monitoring & Alerting

Key Metrics to Watch

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart TD
    subgraph RED["RED Method (for services)"]
        R["Rate<br/>requests/sec"]
        E["Errors<br/>error rate %"]
        D["Duration<br/>p50, p95, p99 latency"]
    end

    subgraph USE["USE Method (for resources)"]
        U["Utilization<br/>% capacity used"]
        S["Saturation<br/>queue depth"]
        Er["Errors<br/>failure count"]
    end

    style R fill:#ECFDF5,stroke:#6EE7B7,color:#1E40AF
    style E fill:#FEE2E2,stroke:#FCA5A5,color:#1E40AF
    style D fill:#FEF3C7,stroke:#FCD34D,color:#1E40AF

Alert Thresholds That Matter

Micrometer + Prometheus Setup

// Custom business metrics
@Component
@RequiredArgsConstructor
public class OrderMetrics {
    private final MeterRegistry registry;

    public void recordOrderPlaced(String region, double amount) {
        registry.counter("orders.placed", "region", region).increment();
        registry.summary("orders.amount", "region", region).record(amount);
    }

    public void recordOrderLatency(String operation, Duration duration) {
        registry.timer("orders.latency", "operation", operation)
                .record(duration);
    }
}

Production Checklist