Quarkus offers two primary execution modes: JVM Mode (traditional Java Virtual Machine) and Native Mode (compiled to native code via GraalVM). Understanding the differences is crucial for choosing the right approach for your application.

Overview and Setup

Dependencies Configuration

<!-- pom.xml - Quarkus Dependencies --> <properties> <quarkus.platform.version>3.8.0</quarkus.platform.version> </properties> <dependencies> <!-- Core Quarkus --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-arc</artifactId> </dependency> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-resteasy-reactive-jackson</artifactId> </dependency> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-hibernate-validator</artifactId> </dependency> <!-- Database --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-hibernate-orm-panache</artifactId> </dependency> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-jdbc-postgresql</artifactId> </dependency> <!-- Testing --> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-junit5</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>io.rest-assured</groupId> <artifactId>rest-assured</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>io.quarkus</groupId> <artifactId>quarkus-maven-plugin</artifactId> <version>${quarkus.platform.version}</version> <extensions>true</extensions> <executions> <execution> <goals> <goal>build</goal> <goal>generate-code</goal> </goals> </execution> </executions> </plugin> </plugins> </build>

Sample Application for Comparison

Example 1: REST API with Database Access

// Entity package com.example.entity; import io.quarkus.hibernate.orm.panache.PanacheEntity; import jakarta.persistence.Entity; import jakarta.validation.constraints.NotBlank; import jakarta.validation.constraints.Size; @Entity public class Product extends PanacheEntity { @NotBlank @Size(min = 3, max = 100) public String name; public String description; public Double price; public Integer stockQuantity; // Constructors public Product() {} public Product(String name, String description, Double price, Integer stockQuantity) { this.name = name; this.description = description; this.price = price; this.stockQuantity = stockQuantity; } } // Repository package com.example.repository; import com.example.entity.Product; import io.quarkus.hibernate.orm.panache.PanacheRepository; import jakarta.enterprise.context.ApplicationScoped; import java.util.List; @ApplicationScoped public class ProductRepository implements PanacheRepository<Product> { public List<Product> findByName(String name) { return find("name like ?1", "%" + name + "%").list(); } public List<Product> findExpensiveProducts(Double minPrice) { return find("price >= ?1", minPrice).list(); } public long countInStock() { return find("stockQuantity > 0").count(); } } // REST Resource package com.example.resource; import com.example.entity.Product; import com.example.repository.ProductRepository; import jakarta.inject.Inject; import jakarta.transaction.Transactional; import jakarta.validation.Valid; import jakarta.ws.rs.*; import jakarta.ws.rs.core.MediaType; import jakarta.ws.rs.core.Response; import java.util.List; @Path("/products") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public class ProductResource { @Inject ProductRepository productRepository; @GET public List<Product> getAllProducts() { return productRepository.listAll(); } @GET @Path("/{id}") public Product getProduct(@PathParam("id") Long id) { Product product = productRepository.findById(id); if (product == null) { throw new WebApplicationException("Product not found", 404); } return product; } @POST @Transactional public Response createProduct(@Valid Product product) { productRepository.persist(product); return Response.status(Response.Status.CREATED).entity(product).build(); } @PUT @Path("/{id}") @Transactional public Product updateProduct(@PathParam("id") Long id, @Valid Product productUpdate) { Product product = productRepository.findById(id); if (product == null) { throw new WebApplicationException("Product not found", 404); } product.name = productUpdate.name; product.description = productUpdate.description; product.price = productUpdate.price; product.stockQuantity = productUpdate.stockQuantity; return product; } @GET @Path("/search") public List<Product> searchProducts(@QueryParam("name") String name) { return productRepository.findByName(name); } @GET @Path("/expensive") public List<Product> getExpensiveProducts(@QueryParam("minPrice") Double minPrice) { return productRepository.findExpensiveProducts(minPrice != null ? minPrice : 100.0); } }

Example 2: Configuration and Additional Services

// Configuration class package com.example.config; import io.smallrye.config.ConfigMapping; import java.util.Optional; @ConfigMapping(prefix = "app") public interface AppConfig { String name(); Optional<String> description(); CacheConfig cache(); interface CacheConfig { boolean enabled(); int ttl(); int maxSize(); } } // Caching service package com.example.service; import com.example.config.AppConfig; import io.quarkus.cache.CacheResult; import jakarta.enterprise.context.ApplicationScoped; import jakarta.inject.Inject; import org.eclipse.microprofile.rest.client.inject.RestClient; import java.time.LocalDateTime; @ApplicationScoped public class ProductService { @Inject AppConfig appConfig; @CacheResult(cacheName = "product-cache") public String getProductInfoWithCache(Long productId) { // Simulate expensive operation simulateProcessing(); return "Product info for ID: " + productId + " at " + LocalDateTime.now(); } private void simulateProcessing() { try { Thread.sleep(100); // Simulate processing time } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } public boolean isCacheEnabled() { return appConfig.cache().enabled(); } } // Scheduled task package com.example.task; import io.quarkus.scheduler.Scheduled; import jakarta.enterprise.context.ApplicationScoped; import jakarta.inject.Inject; import org.jboss.logging.Logger; @ApplicationScoped public class MaintenanceTask { private static final Logger LOG = Logger.getLogger(MaintenanceTask.class); @Inject ProductCleanupService cleanupService; @Scheduled(every = "1h") void cleanupOldProducts() { if (cleanupService.isEnabled()) { LOG.info("Starting scheduled product cleanup"); int cleaned = cleanupService.cleanupOldProducts(); LOG.infof("Cleaned up %d old products", cleaned); } } @Scheduled(every = "5m") void healthCheck() { LOG.debug("Performing health check"); // Health check logic } }

Performance Comparison Tests

Example 3: Performance Benchmarking

package com.example.benchmark; import io.quarkus.test.junit.QuarkusTest; import io.restassured.http.ContentType; import org.junit.jupiter.api.*; import org.junit.jupiter.api.condition.EnabledIfSystemProperty; import static io.restassured.RestAssured.given; import static org.hamcrest.Matchers.*; @QuarkusTest @TestMethodOrder(MethodOrderer.OrderAnnotation.class) public class PerformanceComparisonTest { private static final int WARMUP_ITERATIONS = 100; private static final int MEASUREMENT_ITERATIONS = 1000; @Test @Order(1) @EnabledIfSystemProperty(named = "quarkus.package.type", matches = "jar") public void testJvmModePerformance() { System.out.println("=== JVM MODE PERFORMANCE TEST ==="); runPerformanceTests(); } @Test @Order(2) @EnabledIfSystemProperty(named = "quarkus.package.type", matches = "native") public void testNativeModePerformance() { System.out.println("=== NATIVE MODE PERFORMANCE TEST ==="); runPerformanceTests(); } private void runPerformanceTests() { // Warmup phase for (int i = 0; i < WARMUP_ITERATIONS; i++) { performGetRequest(); performPostRequest(); } // GET request performance long getStartTime = System.currentTimeMillis(); for (int i = 0; i < MEASUREMENT_ITERATIONS; i++) { performGetRequest(); } long getEndTime = System.currentTimeMillis(); // POST request performance long postStartTime = System.currentTimeMillis(); for (int i = 0; i < MEASUREMENT_ITERATIONS; i++) { performPostRequest(); } long postEndTime = System.currentTimeMillis(); System.out.printf("GET Requests: %d requests in %d ms (avg: %.2f ms/req)%n", MEASUREMENT_ITERATIONS, getEndTime - getStartTime, (double)(getEndTime - getStartTime) / MEASUREMENT_ITERATIONS); System.out.printf("POST Requests: %d requests in %d ms (avg: %.2f ms/req)%n", MEASUREMENT_ITERATIONS, postEndTime - postStartTime, (double)(postEndTime - postStartTime) / MEASUREMENT_ITERATIONS); } private void performGetRequest() { given() .when().get("/products") .then() .statusCode(200); } private void performPostRequest() { String productJson = """ { "name": "Test Product", "description": "Performance test product", "price": 99.99, "stockQuantity": 10 } """; given() .contentType(ContentType.JSON) .body(productJson) .when().post("/products") .then() .statusCode(201); } @Test public void testMemoryUsage() { Runtime runtime = Runtime.getRuntime(); long usedMemory = runtime.totalMemory() - runtime.freeMemory(); long maxMemory = runtime.maxMemory(); System.out.printf("Memory Usage: Used=%d MB, Max=%d MB%n", usedMemory / (1024 * 1024), maxMemory / (1024 * 1024)); } @Test public void testStartupTime() { // This would typically be measured during application startup // For demonstration, we'll simulate startup time measurement long simulatedStartupTime = simulateStartupMeasurement(); System.out.printf("Simulated Startup Time: %d ms%n", simulatedStartupTime); } private long simulateStartupMeasurement() { // In real scenarios, this would measure actual startup time // For testing purposes, we return a simulated value String packageType = System.getProperty("quarkus.package.type", "jar"); return "native".equals(packageType) ? 50 : 2000; // Native starts faster } }

Build and Deployment Configuration

Example 4: Docker and Build Configuration

# Dockerfile.jvm - For JVM Mode FROM registry.access.redhat.com/ubi8/openjdk-17-runtime:1.18 ENV LANG='en_US.UTF-8' LANGUAGE='en_US:en' # Configure the JAVA_OPTIONS, you can add -XshowSettings:vm to display heap size ENV JAVA_OPTIONS="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager" COPY target/quarkus-app/lib/ /deployments/lib/ COPY target/quarkus-app/*.jar /deployments/ COPY target/quarkus-app/app/ /deployments/app/ COPY target/quarkus-app/quarkus/ /deployments/quarkus/ EXPOSE 8080 USER 185 ENTRYPOINT [ "java", "-jar", "/deployments/quarkus-run.jar" ]

# Dockerfile.native - For Native Mode FROM registry.access.redhat.com/ubi8/ubi-minimal:8.8 WORKDIR /work/ RUN chown 1001 /work \ && chmod "g+rwX" /work \ && chown 1001:root /work COPY --chown=1001:root target/*-runner /work/application EXPOSE 8080 USER 1001 CMD ["./application", "-Dquarkus.http.host=0.0.0.0"]

# application.properties - Configuration for both modes # Application config app.name=Product Service app.description=Quarkus Product Management Service app.cache.enabled=true app.cache.ttl=3600 app.cache.max-size=1000 # Database configuration quarkus.datasource.db-kind=postgresql quarkus.datasource.username=quarkus quarkus.datasource.password=quarkus quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/quarkusdb # Hibernate configuration quarkus.hibernate-orm.database.generation=drop-and-create quarkus.hibernate-orm.log.sql=true # HTTP configuration quarkus.http.port=8080 quarkus.http.host=0.0.0.0 # Logging quarkus.log.level=INFO quarkus.log.category."com.example".level=DEBUG # Native-specific configuration quarkus.native.additional-build-args=--initialize-at-build-time=org.slf4j.MDC\ --initialize-at-build-time=org.slf4j.LoggerFactory\ --initialize-at-build-time=org.slf4j.impl.StaticLoggerBinder # JVM-specific configuration quarkus.jvm.initial-ram-percentage=50.0 quarkus.jvm.max-ram-percentage=75.0

Build Commands and Execution

Example 5: Build Scripts and Commands

#!/bin/bash # build-and-compare.sh echo "=== Quarkus JVM vs Native Mode Comparison ===" # Build JVM version echo "Building JVM version..." ./mvnw clean package -DskipTests # Build Native version echo "Building Native version..." ./mvnw clean package -Pnative -DskipTests # Display build sizes JVM_SIZE=$(du -h target/quarkus-app | tail -n1 | cut -f1) NATIVE_SIZE=$(du -h target/*-runner | tail -n1 | cut -f1) echo "=== Build Results ===" echo "JVM Mode size: $JVM_SIZE" echo "Native Mode size: $NATIVE_SIZE" # Startup time comparison echo "" echo "=== Startup Time Comparison ===" echo "Starting JVM application..." time java -jar target/quarkus-app/quarkus-run.jar & JVM_PID=$! sleep 10 # Wait for startup kill $JVM_PID echo "" echo "Starting Native application..." time ./target/*-runner & NATIVE_PID=$! sleep 5 # Native starts faster kill $NATIVE_PID

<!-- pom.xml - Build Profiles --> <profiles> <profile> <id>native</id> <properties> <quarkus.package.type>native</quarkus.package.type> <quarkus.native.container-build>true</quarkus.native.container-build> </properties> <dependencies> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-rest-client-reactive-jackson</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>io.quarkus</groupId> <artifactId>quarkus-maven-plugin</artifactId> <executions> <execution> <goals> <goal>native-image</goal> </goals> <configuration> <enableHttpUrlHandler>true</enableHttpUrlHandler> <enableHttpsUrlHandler>true</enableHttpsUrlHandler> </configuration> </execution> </executions> </plugin> </plugins> </build> </profile> </profiles>

Comprehensive Comparison Results

Example 6: Comparison Analysis

package com.example.analysis; import java.util.*; public class QuarkusComparisonAnalysis { public static class ComparisonMetrics { public final String mode; public final long startupTimeMs; public final long buildTimeMs; public final long executableSizeBytes; public final long memoryUsageMb; public final double requestsPerSecond; public final double averageResponseTimeMs; public ComparisonMetrics(String mode, long startupTimeMs, long buildTimeMs, long executableSizeBytes, long memoryUsageMb, double requestsPerSecond, double averageResponseTimeMs) { this.mode = mode; this.startupTimeMs = startupTimeMs; this.buildTimeMs = buildTimeMs; this.executableSizeBytes = executableSizeBytes; this.memoryUsageMb = memoryUsageMb; this.requestsPerSecond = requestsPerSecond; this.averageResponseTimeMs = averageResponseTimeMs; } public void printComparison(ComparisonMetrics other) { System.out.println("=== QUARKUS " + mode + " vs " + other.mode + " MODE COMPARISON ==="); System.out.printf("Startup Time: %d ms vs %d ms (%.2fx %s)%n", startupTimeMs, other.startupTimeMs, (double) other.startupTimeMs / startupTimeMs, startupTimeMs < other.startupTimeMs ? "faster" : "slower"); System.out.printf("Build Time: %d ms vs %d ms (%.2fx %s)%n", buildTimeMs, other.buildTimeMs, (double) other.buildTimeMs / buildTimeMs, buildTimeMs < other.buildTimeMs ? "faster" : "slower"); System.out.printf("Executable Size: %d MB vs %d MB (%.2fx %s)%n", executableSizeBytes / (1024 * 1024), other.executableSizeBytes / (1024 * 1024), (double) other.executableSizeBytes / executableSizeBytes, executableSizeBytes < other.executableSizeBytes ? "smaller" : "larger"); System.out.printf("Memory Usage: %d MB vs %d MB (%.2fx %s)%n", memoryUsageMb, other.memoryUsageMb, (double) other.memoryUsageMb / memoryUsageMb, memoryUsageMb < other.memoryUsageMb ? "less" : "more"); System.out.printf("Throughput: %.2f req/s vs %.2f req/s (%.2fx %s)%n", requestsPerSecond, other.requestsPerSecond, requestsPerSecond / other.requestsPerSecond, requestsPerSecond > other.requestsPerSecond ? "higher" : "lower"); System.out.printf("Response Time: %.2f ms vs %.2f ms (%.2fx %s)%n", averageResponseTimeMs, other.averageResponseTimeMs, other.averageResponseTimeMs / averageResponseTimeMs, averageResponseTimeMs < other.averageResponseTimeMs ? "faster" : "slower"); } } public static void main(String[] args) { // Sample metrics (real values would come from actual measurements) ComparisonMetrics jvmMetrics = new ComparisonMetrics( "JVM", 2000, // startup time 30000, // build time 150 * 1024 * 1024, // executable size (JAR + JVM) 256, // memory usage 850.5, // requests per second 12.3 // average response time ); ComparisonMetrics nativeMetrics = new ComparisonMetrics( "NATIVE", 50, // startup time 120000, // build time 80 * 1024 * 1024, // executable size 45, // memory usage 920.2, // requests per second 10.8 // average response time ); // Print comparison nativeMetrics.printComparison(jvmMetrics); // Print recommendations printRecommendations(jvmMetrics, nativeMetrics); } public static void printRecommendations(ComparisonMetrics jvm, ComparisonMetrics nativeMetrics) { System.out.println("\n=== RECOMMENDATIONS ==="); if (nativeMetrics.startupTimeMs < jvm.startupTimeMs / 10) { System.out.println("✅ Use NATIVE mode for serverless/FaaS deployments"); } if (nativeMetrics.memoryUsageMb < jvm.memoryUsageMb / 2) { System.out.println("✅ Use NATIVE mode for memory-constrained environments"); } if (jvm.buildTimeMs < nativeMetrics.buildTimeMs / 3) { System.out.println("✅ Use JVM mode for development and rapid iteration"); } if (nativeMetrics.requestsPerSecond > jvm.requestsPerSecond * 1.1) { System.out.println("✅ Use NATIVE mode for high-throughput applications"); } if (jvm.averageResponseTimeMs < nativeMetrics.averageResponseTimeMs) { System.out.println("⚠️ JVM mode may have better peak performance for some workloads"); } System.out.println("\n=== GENERAL GUIDELINES ==="); System.out.println("• Use JVM mode for: Development, CI/CD, applications with dynamic class loading"); System.out.println("• Use Native mode for: Production, microservices, serverless, resource-constrained environments"); System.out.println("• Consider: Build time, runtime performance, memory usage, and startup time requirements"); } }

Key Comparison Summary

When to Choose Each Mode

Choose JVM Mode When:

• Development phase with frequent code changes
• Complex applications with dynamic class loading
• Applications requiring extensive reflection
• CI/CD pipelines where build time matters
• Applications with complex classpath requirements

Choose Native Mode When:

• Microservices and serverless deployments
• Resource-constrained environments
• Fast startup time is critical (FaaS, containers)
• Reduced memory footprint is important
• Production deployments with stable code

This comprehensive comparison helps developers make informed decisions about when to use Quarkus in JVM mode versus native mode based on their specific requirements and constraints.