AWS Java Lambda local variables vs object variables

Question

I am trying to find answer to a very specific question. Trying to go through documentation but so far no luck.

Imagine this piece of code

@Override
public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException {
    Request request = parseRequest(input);

    List<String> validationErrors = validate(request);

    if (validationErrors.size() == 0){
        ordersManager.getOrderStatusForStore(orderId, storeId);
    } else {
        generateBadRequestResponse(output, "Invalid Request", null);
    }
}

private List<String> validate(Request request) {
    orderId = request.getPathParameters().get(PATH_PARAM_ORDER_ID);
    programId = request.getPathParameters().get(PATH_PARAM_STORE_ID);
    return new ArrayList<>();
}

Here, I am storing orderId and storeId in field variables. Is this okay? I am not sure if AWS will cache this function and hence cache the field variables or would it initiate a new Java object for every request. If its a new object, then storing in field variable is fine but not sure.

jeff · Accepted Answer · 2017-06-08T01:22:22.360

AWS will spin up a JVM and instantiate an instance of your code on the first request. AWS has an undocumented spin down time, where if you do not invoke your Lambda again within this time limit, it will shut down the JVM. You will notice these initial requests can take significantly longer but once your function is "warmed up", then it will be much quicker.

So to directly answer your question, your instance will be reused if the next request comes in quick enough. Otherwise, a new instance will be stood up.

A simple Lambda function that can illustrate this point:

/**
 * A Lambda handler to see where this runs and when instances are reused.
 */
public class LambdaStatus {

    private String hostname;
    private AtomicLong counter;

    public LambdaStatus() throws UnknownHostException {
        this.counter = new AtomicLong(0L);
        this.hostname = InetAddress.getLocalHost().getCanonicalHostName();
    }

    public void handle(Context context) {
        counter.getAndIncrement();
        context.getLogger().log("hostname=" + hostname + ",counter=" + counter.get());
    }
}

Logs from invoking the above.

22:49:20   hostname=ip-10-12-169-156.ec2.internal,counter=1
22:49:27   hostname=ip-10-12-169-156.ec2.internal,counter=2
22:49:39   hostname=ip-10-12-169-156.ec2.internal,counter=3
01:19:05   hostname=ip-10-33-101-18.ec2.internal,counter=1

score 0 · Answer 2 · answered Jun 07 '17 at 22:55

0

Strongly not recommended.

Multiple invocations may use the same Lambda function instance and this will break your current functionality.

You need to ensure your instance variables are thread safe and can be accessed by multiple threads when it comes to Lambda. Limit your instance variable writes to initialization - once only.

answered Jun 07 '17 at 22:55

Yeshodhan Kulkarni

2,844
1
16
19

2

Your second point i dont think is true, with regard to thread safety... concurrent invocation on a lambda cannot occur, and resources cannot be shared. One invocation must complete before another can start. Explained nicely here https://stackoverflow.com/questions/38016683/aws-lambda-and-java-concurrency – HKalsi May 31 '18 at 21:22

AWS Java Lambda local variables vs object variables

2 Answers2