Performance Test: Java 24 vs. Go 1.26: Startup Time for Serverless Functions with AWS Lambda 2026

// Java 24 Lambda Handler with Project CRaC Support
// Build: mvn clean package (produces target/function.jar)
// CRaC checkpoint: java -XX:CRaCCheckpointTo=/tmp/crac-image -jar target/function.jar
// Deploy to Lambda: aws lambda create-function --function-name java24-crac --runtime java24 --zip-file fileb://target/function.jar --handler com.example.LambdaHandler::handleRequest
package com.example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import org.crac.Core;
import org.crac.Resource;

import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

public class LambdaHandler implements RequestHandler, Resource {
    private static final Logger LOGGER = Logger.getLogger(LambdaHandler.class.getName());
    private static final String CRA_C_CHECKPOINT_DIR = \"/tmp/crac-image\";

    static {
        // Register CRaC resource to run checkpoint logic
        Core.getResources().register(LambdaHandler.class);
        LOGGER.info(\"Registered CRaC resource for checkpoint\");
    }

    public LambdaHandler() {
        LOGGER.info(\"Initializing Java 24 Lambda Handler\");
        // Simulate heavy startup work: load config, initialize DB pool, etc.
        initializeDependencies();
    }

    private void initializeDependencies() {
        try {
            // Simulate 200ms of startup work (DB connection, config load)
            Thread.sleep(200);
            LOGGER.info(\"Dependencies initialized successfully\");
        } catch (InterruptedException e) {
            LOGGER.log(Level.SEVERE, \"Dependency initialization interrupted\", e);
            Thread.currentThread().interrupt();
        }
    }

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        Map headers = new HashMap<>();
        headers.put(\"Content-Type\", \"application/json\");
        headers.put(\"X-Runtime\", \"Java 24 (CRaC)\");

        APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent()
                .withStatusCode(200)
                .withHeaders(headers);

        try {
            // Simulate 5ms of business logic
            Thread.sleep(5);
            String responseBody = String.format(\"{\\\"message\\\": \\\"Hello from Java 24 Lambda\\\", \\\"requestId\\\": \\\"%s\\\"}\", context.getAwsRequestId());
            response.withBody(responseBody);
        } catch (InterruptedException e) {
            LOGGER.log(Level.WARNING, \"Request processing interrupted\", e);
            response.withStatusCode(500)
                    .withBody(\"{\\\"error\\\": \\\"Internal server error\\\"}\");
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            LOGGER.log(Level.SEVERE, \"Unhandled exception in request processing\", e);
            response.withStatusCode(500)
                    .withBody(\"{\\\"error\\\": \\\"Internal server error\\\"}\");
        }

        return response;
    }

    @Override
    public void beforeCheckpoint(org.crac.Context context) throws Exception {
        LOGGER.info(\"Running beforeCheckpoint hook: closing non-serializable resources\");
        // Close any non-serializable resources here (e.g., open sockets)
    }

    @Override
    public void afterRestore(org.crac.Context context) throws Exception {
        LOGGER.info(\"Running afterRestore hook: reopening non-serializable resources\");
        // Reopen resources that were closed during checkpoint
    }

    public static void main(String[] args) {
        // Local testing entry point
        LambdaHandler handler = new LambdaHandler();
        APIGatewayProxyRequestEvent testEvent = new APIGatewayProxyRequestEvent();
        Context testContext = new TestContext();
        APIGatewayProxyResponseEvent response = handler.handleRequest(testEvent, testContext);
        System.out.println(\"Test response: \" + response.getBody());
    }

    // Mock Context for local testing
    static class TestContext implements Context {
        @Override public String getAwsRequestId() { return \"test-request-id\"; }
        @Override public String getFunctionName() { return \"java24-crac\"; }
        @Override public String getFunctionVersion() { return \"1.0.0\"; }
        @Override public String getInvokedFunctionArn() { return \"arn:aws:lambda:us-east-1:123456789012:function:java24-crac\"; }
        @Override public String getIdentity() { return null; }
        @Override public String getLogGroupName() { return \"/aws/lambda/java24-crac\"; }
        @Override public String getLogStreamName() { return \"2026/03/15/[$LATEST]test\"; }
        @Override public String getMemoryLimitInMB() { return \"1024\"; }
        @Override public Integer getRemainingTimeInMillis() { return 300000; }
        @Override public String getLogMessage() { return null; }
    }
}

// Go 1.26 Lambda Function for AWS Lambda
// Build: GOOS=linux GOARCH=arm64 go build -o bootstrap main.go
// Deploy: aws lambda create-function --function-name go126-lambda --runtime go1.26 --zip-file fileb://main.zip --handler bootstrap
package main

import (
    \"context\"\"encoding/json\"\"fmt\"\"log\"\"net/http\"\"os\"\"time\"\"github.com/aws/aws-lambda-go/events\"\"github.com/aws/aws-lambda-go/lambda\"
)

// Response structure for API Gateway
type Response struct {
    Message   string `json:\"message\"`
    RequestID string `json:\"requestId\"`
    Runtime   string `json:\"runtime\"`
}

// Config holds function configuration
type Config struct {
    Environment string `json:\"environment\"`
    Region      string `json:\"region\"`
}

var (
    // Pre-initialized dependencies to isolate startup from handler logic
    cfg     *Config
    logger  *log.Logger
    startup time.Time
)

func init() {
    // Runs on cold start: simulate heavy startup work (DB connection, config load)
    startup = time.Now()
    logger = log.New(os.Stdout, \"[Go1.26-Lambda] \", log.Ldate|log.Ltime|log.Lmicroseconds)

    logger.Println(\"Initializing Go 1.26 Lambda dependencies\")
    start := time.Now()

    // Simulate 150ms of startup work (config load, DB pool init)
    time.Sleep(150 * time.Millisecond)

    // Load config from environment
    cfg = &Config{
        Environment: getEnv(\"ENVIRONMENT\", \"production\"),
        Region:      getEnv(\"AWS_REGION\", \"us-east-1\"),
    }

    logger.Printf(\"Dependencies initialized in %v\", time.Since(start))
}

// getEnv retrieves environment variable or returns default
func getEnv(key, defaultVal string) string {
    if val, ok := os.LookupEnv(key); ok {
        return val
    }
    return defaultVal
}

// handler processes API Gateway proxy requests
func handler(ctx context.Context, request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
    start := time.Now()
    logger.Printf(\"Processing request %s\", request.RequestContext.RequestID)

    // Simulate 3ms of business logic
    time.Sleep(3 * time.Millisecond)

    // Build response
    resp := Response{
        Message:   \"Hello from Go 1.26 Lambda\",
        RequestID: request.RequestContext.RequestID,
        Runtime:   \"Go 1.26\",
    }

    respBody, err := json.Marshal(resp)
    if err != nil {
        logger.Printf(\"Failed to marshal response: %v\", err)
        return events.APIGatewayProxyResponse{
            StatusCode: http.StatusInternalServerError,
            Headers: map[string]string{
                \"Content-Type\": \"application/json\",
            },
            Body: `{\"error\": \"Internal server error\"}`,
        }, nil
    }

    logger.Printf(\"Request processed in %v\", time.Since(start))

    return events.APIGatewayProxyResponse{
        StatusCode: http.StatusOK,
        Headers: map[string]string{
            \"Content-Type\": \"application/json\",
            \"X-Runtime\":    \"Go 1.26\",
        },
        Body: string(respBody),
    }, nil
}

func main() {
    // Start Lambda runtime
    logger.Println(\"Starting Go 1.26 Lambda runtime\")
    lambda.Start(handler)
}

#!/usr/bin/env python3
# Lambda Cold Start Benchmark Script
# Requires: boto3, pandas, matplotlib
# Usage: python benchmark.py --function-arn arn:aws:lambda:us-east-1:123456789012:function:java24-crac --iterations 1000

import argparse
import boto3
import time
import json
import pandas as pd
import logging
from datetime import datetime
from typing import List, Dict

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format=\"%(asctime)s - %(levelname)s - %(message)s\"
)
logger = logging.getLogger(__name__)

class LambdaBenchmarker:
    def __init__(self, function_arn: str, region: str = \"us-east-1\"):
        self.function_arn = function_arn
        self.region = region
        self.lambda_client = boto3.client(\"lambda\", region_name=region)
        self.cloudwatch = boto3.client(\"cloudwatch\", region_name=region)
        self.results: List[Dict] = []

    def invoke_function(self, force_cold_start: bool = False) -> Dict:
        \"\"\"Invoke Lambda function and return timing metrics\"\"\"
        try:
            # Force cold start by updating function config (no-op) to cycle container
            if force_cold_start:
                self.lambda_client.update_function_configuration(
                    FunctionName=self.function_arn,
                    Environment={\"Variables\": {\"LAST_UPDATED\": str(datetime.now().timestamp())}}
                )
                # Wait for config update to propagate
                time.sleep(5)

            start = time.perf_counter()
            response = self.lambda_client.invoke(
                FunctionName=self.function_arn,
                InvocationType=\"RequestResponse\",
                Payload=json.dumps({\"httpMethod\": \"GET\", \"path\": \"/\"})
            )
            end = time.perf_counter()

            duration_ms = (end - start) * 1000
            payload = json.loads(response[\"Payload\"].read().decode())
            status_code = payload.get(\"statusCode\", 500)

            return {
                \"timestamp\": datetime.now().isoformat(),
                \"duration_ms\": duration_ms,
                \"status_code\": status_code,
                \"cold_start\": force_cold_start,
                \"request_id\": response.get(\"ResponseMetadata\", {}).get(\"RequestId\", \"unknown\")
            }
        except Exception as e:
            logger.error(f\"Failed to invoke function: {e}\")
            return {
                \"timestamp\": datetime.now().isoformat(),
                \"duration_ms\": -1,
                \"status_code\": 500,
                \"cold_start\": force_cold_start,
                \"request_id\": \"error\",
                \"error\": str(e)
            }

    def run_benchmark(self, iterations: int = 1000, cold_start_interval: int = 30) -> pd.DataFrame:
        \"\"\"Run benchmark with specified iterations\"\"\"
        logger.info(f\"Starting benchmark for {self.function_arn} with {iterations} iterations\")
        for i in range(iterations):
            # Force cold start every cold_start_interval iterations
            force_cold = (i % cold_start_interval == 0) or (i == 0)
            if force_cold and i > 0:
                logger.info(f\"Iteration {i}: Forcing cold start\")
                # Wait 30s to ensure container is cycled
                time.sleep(30)

            result = self.invoke_function(force_cold)
            self.results.append(result)

            if i % 100 == 0:
                logger.info(f\"Completed {i}/{iterations} iterations\")

        df = pd.DataFrame(self.results)
        # Filter out error results
        df = df[df[\"duration_ms\"] > 0]
        logger.info(f\"Benchmark complete. Collected {len(df)} valid results\")
        return df

    def save_results(self, df: pd.DataFrame, output_path: str = \"benchmark_results.csv\"):
        \"\"\"Save results to CSV and generate summary stats\"\"\"
        df.to_csv(output_path, index=False)
        logger.info(f\"Saved results to {output_path}\")

        # Print summary stats
        cold = df[df[\"cold_start\"] == True]
        warm = df[df[\"cold_start\"] == False]

        print(\"\\n=== Benchmark Summary ===\")
        print(f\"Function ARN: {self.function_arn}\")
        print(f\"Total Iterations: {len(df)}\")
        print(f\"Cold Starts: {len(cold)}\")
        print(f\"Warm Starts: {len(warm)}\")
        print(f\"Cold Start Avg (ms): {cold['duration_ms'].mean():.2f} ± {cold['duration_ms'].std():.2f}\")
        print(f\"Warm Start Avg (ms): {warm['duration_ms'].mean():.2f} ± {warm['duration_ms'].std():.2f}\")
        print(f\"Cold Start P99 (ms): {cold['duration_ms'].quantile(0.99):.2f}\")
        print(f\"Warm Start P99 (ms): {warm['duration_ms'].quantile(0.99):.2f}\")

def main():
    parser = argparse.ArgumentParser(description=\"AWS Lambda Cold Start Benchmarker\")
    parser.add_argument(\"--function-arn\", required=True, help=\"Lambda function ARN to benchmark\")
    parser.add_argument(\"--iterations\", type=int, default=1000, help=\"Number of benchmark iterations\")
    parser.add_argument(\"--region\", type=str, default=\"us-east-1\", help=\"AWS region\")
    parser.add_argument(\"--output\", type=str, default=\"benchmark_results.csv\", help=\"Output CSV path\")
    args = parser.parse_args()

    benchmarker = LambdaBenchmarker(args.function_arn, args.region)
    df = benchmarker.run_benchmark(args.iterations)
    benchmarker.save_results(df, args.output)

if __name__ == \"__main__\":
    main()

// Register CRaC resource in static initializer
static {
    Core.getResources().register(new LambdaHandler());
}

CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -trimpath -o bootstrap main.go

import \"github.com/aws/aws-embedded-metrics-golang/metrics\"

func emitStartupMetric(duration time.Duration) {
    m := metrics.NewMetrics()
    m.PutMetric(\"StartupTimeMs\", duration.Milliseconds())
    m.SetDimensions(map[string]string{\"Function\": \"go126-lambda\", \"MetricType\": \"ColdStart\"})
    m.Validate()
}