AWS Lambda performance problem with multi-threading

I have a AWS Lambda function that calls a child AWS Lambda function 10 times, each invocation in a separate thread. The child Lambda times itself and returns the timing as the only thing in the body of the response. Here is the parent function:

import boto3
import json
import threading
from stats import Timer

client = boto3.client('lambda')

def do_lambda():
    timer = Timer()
    response = client.invoke(
        FunctionName = 'arn:aws:lambda:us-east-1:497857710590:function:child-function',
        InvocationType = 'RequestResponse',
        Payload = json.dumps({'keys': 1}))
    print(f"Thread done after {timer.stop()}ms: {json.load(response['Payload'])}")

def do_work(n_threads):
    threads = []
    for i in range(n_threads):
        thread = threading.Thread(target=do_lambda, args=())
        thread.start()
        threads.append(thread)

    for thread in threads:
        thread.join()
    

def lambda_handler(event, context):
    do_work(10)
    return {
        'statusCode': 200,
        'body': json.dumps('Hello from Lambda!')
    }

The output:

Thread done after 569ms: {'statusCode': 200, 'body': '"553ms"'}
Thread done after 575ms: {'statusCode': 200, 'body': '"558ms"'}
Thread done after 571ms: {'statusCode': 200, 'body': '"555ms"'}
Thread done after 575ms: {'statusCode': 200, 'body': '"559ms"'}
Thread done after 591ms: {'statusCode': 200, 'body': '"575ms"'}
Thread done after 597ms: {'statusCode': 200, 'body': '"580ms"'}
Thread done after 598ms: {'statusCode': 200, 'body': '"573ms"'}
Thread done after 622ms: {'statusCode': 200, 'body': '"603ms"'}
Thread done after 631ms: {'statusCode': 200, 'body': '"575ms"'}
Thread done after 2256ms: {'statusCode': 200, 'body': '"614ms"'}

As you see, the last invocation of the child Lambda took 614ms. However, it took more than 2 seconds for the thread to be actually done. I get this result with one thread taking much longer to be joined consistently. Increasing RAM to 10240 MB does not solve this. If I only use 9 threads, all is fine and all threads are joined in about 650ms.

What is the explanation for this performance limitation of multi-threading under AWS Lambda?

UPDATE: After additional experimentation, I have a different understanding of the question and decided to post that separately under a different title that reflects the new understanding.