How to Slash Cold‑Start Delays for Spring Boot on Serverless Platforms

Understanding the Cold‑Start Problem

Spring Boot packages many components, so when a function is invoked for the first time after a period of inactivity, the platform must download code or image (PrepareCode), start the JVM and load the application (RuntimeInitialization), run any custom Initializer logic (Initialization), and finally handle the request (Invocation). In the Mall demo, the total startup time is about 30 seconds, which is unacceptable for real‑time user experiences.

Analyzing Cold‑Start Stages

PrepareCode : downloading the code package or container image; with image acceleration enabled, this step is very short.

RuntimeInitialization : JVM start‑up and Spring Boot bootstrapping, which consumes most of the delay.

Initialization : execution of user‑defined Initializer code.

Invocation : actual request processing, typically negligible.

Optimization 1 – Use Reserved Instances

Reserved instances keep a minimum number of function containers warm, eliminating cold‑start latency. In the Alibaba Cloud Function Compute console, set the minimum and maximum instance counts on the “Elastic Scaling” page, optionally defining time‑based or metric‑based reservation rules. Once the reserved instances are ready, subsequent invocations experience no cold start.

Optimization 2 – Speed Up Instance Startup

Lazy Initialization

Enable Spring Boot’s global lazy‑initialization flag (available from version 2.2) to defer bean creation until first use, reducing startup time at the cost of a slightly longer first request.

SPRING_MAIN_LAZY_INITIALIZATION=true

Disable JIT Optimizations

For short‑lived serverless functions, turn off tiered JIT compilation to cut JVM warm‑up time.

JAVA_TOOL_OPTIONS="-XX:+TieredCompilation -XX:TieredStopAtLevel=1"

Optimization 3 – Configure Reasonable Instance Parameters

Choose an appropriate instance size (e.g., 2C4G or 4C8G) and set the instance concurrency limit, which defines how many simultaneous requests a single instance can handle. Use load‑testing tools to measure TPS and latency, then adjust the concurrency value following these steps:

Set the function’s maximum instance count to 1 to isolate single‑instance performance.

Run a load test and record TPS and response latency.

Incrementally increase the concurrency limit; if performance remains stable, continue raising it, otherwise lower it.

This approach ensures the system can quickly scale out when load exceeds the configured concurrency, providing smooth performance without over‑provisioning.

Reference Links

Spring Boot project: https://spring.io/projects/spring-boot

Mall demo repository (50k+ stars): https://github.com/macrozheng/mall

Serverless Devs CLI installation: http://serverlessdevs.com/zhcn/docs/installed/cliinstall.html

Alibaba Cloud Function Compute product page: https://www.aliyun.com/product/fc