Java 21 vs. .NET 9: Memory Usage Benchmarks for Enterprise Apps

// Java 21 Virtual Thread REST API with ZGC and Memory Metrics
// Requires: Spring Boot 3.2, Java 21+, Micrometer Prometheus
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import org.springframework.http.HttpStatus;
import java.util.concurrent.ThreadLocalRandom;
import java.util.ArrayList;
import java.util.List;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.binder.jvm.JvmMemoryMetrics;
import io.micrometer.prometheus.PrometheusConfig;
import io.micrometer.prometheus.PrometheusMeterRegistry;

@SpringBootApplication
public class EnterpriseRestApi {
    private final PrometheusMeterRegistry prometheusRegistry;
    private final MeterRegistry meterRegistry;

    public EnterpriseRestApi() {
        this.prometheusRegistry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
        this.meterRegistry = prometheusRegistry;
        new JvmMemoryMetrics().bindTo(meterRegistry);
    }

    public static void main(String[] args) {
        // Enable virtual threads (Project Loom) and ZGC via JVM args:
        // -XX:+UseZGC -XX:+ZGenerational -Dspring.threads.virtual.enabled=true
        SpringApplication.run(EnterpriseRestApi.class, args);
    }

    @RestController
    @RequestMapping(\"/api/v1/orders\")
    static class OrderController {
        private final OrderService orderService;
        private final MeterRegistry meterRegistry;

        public OrderController(OrderService orderService, MeterRegistry meterRegistry) {
            this.orderService = orderService;
            this.meterRegistry = meterRegistry;
            meterRegistry.counter(\"orders.requests.total\").increment(0);
        }

        @GetMapping(\"/{id}\")
        public ResponseEntity getOrder(@PathVariable Long id) {
            try {
                Order order = orderService.findOrder(id);
                meterRegistry.counter(\"orders.retrieved.total\").increment();
                return ResponseEntity.ok(order);
            } catch (IllegalArgumentException e) {
                meterRegistry.counter(\"orders.errors.invalid_id.total\").increment();
                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
            } catch (Exception e) {
                meterRegistry.counter(\"orders.errors.internal.total\").increment();
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
            }
        }

        @PostMapping
        public ResponseEntity createOrder(@RequestBody OrderRequest request) {
            try {
                if (request.quantity() <= 0) {
                    throw new IllegalArgumentException(\"Quantity must be positive\");
                }
                Order order = orderService.createOrder(request);
                meterRegistry.counter(\"orders.created.total\").increment();
                return ResponseEntity.status(HttpStatus.CREATED).body(order);
            } catch (IllegalArgumentException e) {
                meterRegistry.counter(\"orders.errors.invalid_request.total\").increment();
                return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(null);
            } catch (Exception e) {
                meterRegistry.counter(\"orders.errors.internal.total\").increment();
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
            }
        }
    }

    @Service
    static class OrderService {
        private final List orders = new ArrayList<>();
        private long nextId = 1;

        public Order findOrder(Long id) {
            return orders.stream()
                    .filter(o -> o.id().equals(id))
                    .findFirst()
                    .orElseThrow(() -> new IllegalArgumentException(\"Order not found\"));
        }

        public Order createOrder(OrderRequest request) {
            Order order = new Order(nextId++, request.customerId(), request.quantity(), ThreadLocalRandom.current().nextDouble(100));
            orders.add(order);
            return order;
        }
    }

    // Record classes for request/response
    record OrderRequest(Long customerId, int quantity) {}
    record Order(Long id, Long customerId, int quantity, double total) {}

    @Bean
    public PrometheusMeterRegistry prometheusRegistry() {
        return prometheusRegistry;
    }
}

// .NET 9 ASP.NET Core REST API with Server GC and Memory Metrics
// Requires: ASP.NET Core 9, OpenTelemetry, Prometheus exporter
// Run with: dotnet run --settings \"GCSettings:ServerGC=true\"
using Microsoft.AspNetCore.Mvc;
using OpenTelemetry;
using OpenTelemetry.Metrics;
using Prometheus;
using System.Runtime;

var builder = WebApplication.CreateBuilder(args);

// Enable Server GC for multi-core workloads (default for .NET 9 on >1 core)
// For single core, use Workstation GC: GCSettings.GCType = GCLargeObjectHeapCompactionMode.Default;
builder.Services.AddControllers();
builder.Services.AddSingleton();

// Configure Prometheus metrics
var prometheusRegistry = Metrics.NewCustomRegistry();
builder.Services.AddOpenTelemetry()
    .WithMetrics(otel =>
    {
        otel.AddAspNetCoreInstrumentation()
            .AddRuntimeInstrumentation()
            .AddPrometheusExporter(opt =>
            {
                opt.Registry = prometheusRegistry;
            });
    });

var app = builder.Build();

app.MapControllers();
app.MapPrometheusScrapingEndpoint(\"/metrics\");

// Order controller
app.MapGet(\"/api/v1/orders/{id}\", (long id, OrderService orderService, ILogger logger) =>
{
    try
    {
        var order = orderService.FindOrder(id);
        PrometheusMetrics.OrderRetrievedCounter.Inc();
        return Results.Ok(order);
    }
    catch (ArgumentException e)
    {
        PrometheusMetrics.InvalidIdCounter.Inc();
        logger.LogWarning(e, \"Invalid order ID requested\");
        return Results.BadRequest(\"Order not found\");
    }
    catch (Exception e)
    {
        PrometheusMetrics.InternalErrorCounter.Inc();
        logger.LogError(e, \"Internal error retrieving order\");
        return Results.StatusCode(500);
    }
});

app.MapPost(\"/api/v1/orders\", (OrderRequest request, OrderService orderService, ILogger logger) =>
{
    try
    {
        if (request.Quantity <= 0)
        {
            throw new ArgumentException(\"Quantity must be positive\");
        }
        var order = orderService.CreateOrder(request);
        PrometheusMetrics.OrderCreatedCounter.Inc();
        return Results.Created($"/api/v1/orders/{order.Id}", order);
    }
    catch (ArgumentException e)
    {
        PrometheusMetrics.InvalidRequestCounter.Inc();
        logger.LogWarning(e, \"Invalid order request\");
        return Results.BadRequest(e.Message);
    }
    catch (Exception e)
    {
        PrometheusMetrics.InternalErrorCounter.Inc();
        logger.LogError(e, \"Internal error creating order\");
        return Results.StatusCode(500);
    }
});

app.Run();

// Static class for Prometheus metrics
public static class PrometheusMetrics
{
    public static readonly Counter OrderRetrievedCounter = Metrics.CreateCounter(\"orders_retrieved_total\", \"Total orders retrieved\");
    public static readonly Counter OrderCreatedCounter = Metrics.CreateCounter(\"orders_created_total\", \"Total orders created\");
    public static readonly Counter InvalidIdCounter = Metrics.CreateCounter(\"orders_errors_invalid_id_total\", \"Invalid order ID errors\");
    public static readonly Counter InvalidRequestCounter = Metrics.CreateCounter(\"orders_errors_invalid_request_total\", \"Invalid order request errors\");
    public static readonly Counter InternalErrorCounter = Metrics.CreateCounter(\"orders_errors_internal_total\", \"Internal server errors\");
}

// Order service
public class OrderService
{
    private readonly List _orders = [];
    private long _nextId = 1;

    public Order FindOrder(long id)
    {
        var order = _orders.FirstOrDefault(o => o.Id == id);
        return order ?? throw new ArgumentException(\"Order not found\");
    }

    public Order CreateOrder(OrderRequest request)
    {
        var order = new Order(_nextId++, request.CustomerId, request.Quantity, Random.Shared.NextDouble() * 100);
        _orders.Add(order);
        return order;
    }
}

// Record types for request/response
public record OrderRequest(long CustomerId, int Quantity);
public record Order(long Id, long CustomerId, int Quantity, double Total);

// Java 21 Batch Processor for 1M records with memory tracking
// Requires: Java 21+, Micrometer, Prometheus
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.binder.jvm.JvmMemoryMetrics;
import io.micrometer.prometheus.PrometheusConfig;
import io.micrometer.prometheus.PrometheusMeterRegistry;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

public class BatchProcessor {
    private final MeterRegistry meterRegistry;
    private final PrometheusMeterRegistry prometheusRegistry;
    private final ExecutorService virtualThreadExecutor;

    public BatchProcessor() {
        this.prometheusRegistry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
        this.meterRegistry = prometheusRegistry;
        new JvmMemoryMetrics().bindTo(meterRegistry);
        // Use virtual threads for I/O bound batch tasks
        this.virtualThreadExecutor = Executors.newVirtualThreadPerTaskExecutor();
    }

    public void processBatch(int recordCount) {
        long startTime = System.currentTimeMillis();
        List processedRecords = new ArrayList<>(recordCount);
        meterRegistry.counter(\"batch.processed.total\").increment(0);

        try {
            for (int i = 0; i < recordCount; i++) {
                final int recordId = i;
                virtualThreadExecutor.submit(() -> {
                    try {
                        Record raw = fetchRecord(recordId);
                        Record processed = transformRecord(raw);
                        processedRecords.add(processed);
                        meterRegistry.counter(\"batch.records.processed.total\").increment();
                    } catch (Exception e) {
                        meterRegistry.counter(\"batch.records.errors.total\").increment();
                        System.err.println(\"Error processing record \" + recordId + \": \" + e.getMessage());
                    }
                });
            }
        } catch (Exception e) {
            meterRegistry.counter(\"batch.errors.total\").increment();
            System.err.println(\"Batch failed: \" + e.getMessage());
        } finally {
            virtualThreadExecutor.shutdown();
            try {
                if (!virtualThreadExecutor.awaitTermination(5, TimeUnit.MINUTES)) {
                    virtualThreadExecutor.shutdownNow();
                }
            } catch (InterruptedException e) {
                virtualThreadExecutor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }

        long endTime = System.currentTimeMillis();
        meterRegistry.gauge(\"batch.duration.ms\", endTime - startTime);
        System.out.println(\"Processed \" + processedRecords.size() + \" records in \" + (endTime - startTime) + \"ms\");
        System.out.println(\"Prometheus metrics: \" + prometheusRegistry.scrape());
    }

    private Record fetchRecord(int id) {
        // Simulate DB fetch with random delay
        try {
            Thread.sleep(ThreadLocalRandom.current().nextInt(1, 5));
            return new Record(id, \"raw-\" + id, ThreadLocalRandom.current().nextDouble(1000));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    private Record transformRecord(Record raw) {
        // Simulate transformation
        return new Record(raw.id(), \"transformed-\" + raw.name(), raw.value() * 1.1);
    }

    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println(\"Usage: BatchProcessor \");
            System.exit(1);
        }
        int recordCount = Integer.parseInt(args[0]);
        BatchProcessor processor = new BatchProcessor();
        processor.processBatch(recordCount);
    }

    record Record(int id, String name, double value) {}
}