Início / coding / Perguntas / 77439647
Accepted
AlwaysLearning
Asked: 2023-11-07 23:51:23 +0800 CST

Tempo não contabilizado com ThreadPoolExecutor

  • 772

Eu tenho uma função AWS Lambda:

import boto3
import json
import concurrent.futures
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:wherewasit-search',
        InvocationType = 'RequestResponse',
        Payload = json.dumps({'keys': 1}))
    payload = json.loads(json.load(response['Payload'])['body'])
    print(f"Response after {timer.stop()}ms")

def do_work(n_threads):
    timer = Timer()
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = []
        for i in range(n_threads):
            futures.append(executor.submit(do_lambda))
        for future in concurrent.futures.as_completed(futures):
            pass
    print(f"Joined all: {timer.stop()}ms")

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

A saída:

Response after 1236ms
Response after 1242ms
Response after 1251ms
Response after 1272ms
Response after 1322ms
Response after 1359ms
Response after 1126ms
Response after 1170ms
Response after 1246ms
Joined all: 2496ms

Dado que todos os threads são concluídos em no máximo 1,4 segundos, quanto é gasto outro segundo antes que todos os threads sejam unidos?

1 respostas

  1. Best Answer

    Talvez o seu problema não tenha nada a ver com AWS ou boto3. Tente executar isto:

    #!/usr/bin/env python3

import time
import concurrent.futures

class Timer:
    def __init__(self):
        self.start_time = time.time()
    def stop(self):
        return 1000*(time.time() - self.start_time)

def do_lambda():
    timer = Timer()
    time.sleep(1.2)
    print(f"Response after {timer.stop()}ms")

def do_work(n_threads):
    timer = Timer()
    with concurrent.futures.ThreadPoolExecutor(max_workers=8) as executor:
        futures = []
        for i in range(n_threads):
            futures.append(executor.submit(do_lambda))
        for future in concurrent.futures.as_completed(futures):
            pass
    print(f"Joined all: {timer.stop()}ms")

if __name__ == "__main__":
    do_work(9)

    Deve produzir uma saída muito semelhante à saída do seu programa. O tempo de "Junção de todos" é aproximadamente o dobro do tempo de "Resposta após" impresso por qualquer uma das nove do_lambda()chamadas porque o conjunto de encadeamentos não pode ter mais de oito trabalhadores. A última do_lambda()chamada não pode começar até que pelo menos uma das outras tenha terminado.

    Meu programa especifica explicitamente max_workers. Seu programa cria um pool de threads com o número máximo padrão de trabalhadores. Qual é esse número? (O padrão na minha instalação do Python parece ser 12.) Se for menor que nove, mas maior que quatro, então o comportamento do seu programa é praticamente o que você deveria esperar.

    Explicação alternativa: (Isso parece menos provável, mas não sei nada sobre boto3, então talvez...)

    Talvez haja algum recurso em pool que boto3seja usado e talvez o tamanho padrão desse pool seja menor que nove, mas maior que quatro.

    • 1

relate perguntas