What happens when I start a new thread in lambda function and return

Question

When I start a new thread in lambda function and return, it look like it stops execution of new threads and close.

public class Importer implements RequestHandler<Request<ImportJob>, Response> {

@Override
public Response handleRequest(final Request<ImportJob> request, final Context context) {

    CompletableFuture.runAsync(() -> uploadOriginalFile(importJob), ioThreadPool)
        .thenRunAsync(() -> convert(importJob), importThreadPool)
        .thenRun(() -> createThumbnail(importJob))
        .handleAsync((r, cause) -> completeJob(importJob, cause), ioThreadPool);

    return new Response("Execution started");
  }
}

When I wait for the execution of all CompletableFuture using join(), It run as I expect but when I try run it in aysnc it, returns the reponse immediately and terminated. Is there any other way to run lambda in async or I am doing something wrong ?

Answer 1

Is there any other way to run lambda in async or I am doing something wrong?

Lambda functions can be invoked using the synchronous "request/response" model, or the asynchronous "event" model. These two invocation types ultimately have nothing to do with the way the code inside the Lambda function works.

• RequestResponse (synchronous) - the Lambda API call doesn't return until the function returns a response or error or the invocation runs past the allowed time; failures must be retried by invoking the again, yourself.
• Event (asynchronous) - the Lambda API call returns immediately, and the function runs to completion, with its output discarded; failures are retried twice.

It seems as if you are invoking the function using request/response, but then trying to continue to work after returning a response, which overlooks an intrinsic part of the design of the Lambda service. Each invocation runs until it is finished, and then it returns a response. When invoked asynchronously, the response is discarded, but that response is what signals the end of execution, that the function has either succeeded or failed at its task. Lambda stops the billing timer and freezes or destroys the container at that point. A synchronous response cannot be returned earlier than the end of execution.

Lambda runs only one concurrent invocation within each container, so you don't need multiple threads unless an individual invocation is doing more than one thing that needs its own thread.

If you need output from the Lambda function and more processing to continue in the background, then you need function1 invoked request/response, and function1 needs to call the Lambda service API and invoke function2 asynchronously.

In this case, you don't appear to actually need the output, so you could invoke this function asynchronously from API Gateway by adding the X-Amz-Invocation-Type:Event header to the integration request -- but your function needs to "block" until it is done -- that is, it should not return a response until it is finished processing (and remember, the response will be discarded). This may seem counter-intuitive, until you remember that each parallel invocation runs in its own container.