AWS Lambda - Java 静态初始化

Question

Inside AWS lambda function (written in Java) I want to use AsyncHttpClient ( https://github.com/AsyncHttpClient/async-http-client ). Unfortunately it takes around 500 ms to create an instance of this object.. (but I still like it, please don't advice me to change the http client).

I was considering creating AsyncHttpClient in static initialization block. So maybe it will be executed once by AWS and than the snapshot would be cloned for the every AWS Lambda execution. Am I correct?

When static block are executed in AWS Lambda?

• Once and than the snapshot is cloned to every AWS Lambda invocation
• or static block is executed for every Lambda execution separately (and it will not help to put creation of Http Client there)

Thank you for help

Answer 1

There is no "snapshot" taken of your Lambda execution environment, ever. There is however a concept of container reuse. A static initialization block will be called when the function runs for the first time in a new container, and each subsequent Lambda execution that is sent to that container will be able to skip the initialization step. Each time Lambda spins up a new container for your Lambda function that initialization work will need to happen again.

I suggest reading this post on the AWS blog about Lambda container reuse.

Answer 2

As Mark B explained, there is no such thing as a 'snapshot'.

AWS starts an execution context the first time your Lambda is called and then reuses it for the next requests. However, this is not guaranteed. AWS may shut down this context at any time, or create others to scale your Lambda in case your of heavy load.

An execution context consists of the container, the JVM, and a Singleton instance of the Java class where your handler function is defined.

Therefore, I would not recommend doing any "one-time" initialization in a static block, but instead in the constructor of your class. This will greatly improve the testability of your code.

Answer 3

You can configure AWS Snapstart which will save the state of your lambda after init. I just saw a 1/6 reduced cold start times on a simple java lambda.

From AWS Documentation Linked above: "Lambda SnapStart for Java can improve startup performance for latency-sensitive applications by up to 10x at no extra cost, typically with no changes to your function code. The largest contributor to startup latency (often referred to as cold start time) is the time that Lambda spends initializing the function, which includes loading the function's code, starting the runtime, and initializing the function code.

With SnapStart, Lambda initializes your function when you publish a function version. Lambda takes a Firecracker microVM snapshot of the memory and disk state of the initialized execution environment, encrypts the snapshot, and caches it for low-latency access. When you invoke the function version for the first time, and as the invocations scale up, Lambda resumes new execution environments from the cached snapshot instead of initializing them from scratch, improving startup latency."