Cancelamento de chamadas de função de longa duração com tempos limites

Ao executar scripts complexos que incluem funções potencialmente paralisadas, é desejável fornecer uma maneira de encerrar essas funções se elas excederem um tempo de execução especificado. Isso garante que o script não pare de responder ou permaneça travado indefinidamente.

Em Python, aproveitar o pacote signal (disponível em sistemas UNIX) oferece uma solução para esse problema. Ao registrar um manipulador de sinal, você pode definir um tempo limite para uma chamada de função. Se a função demorar mais do que o tempo especificado, o manipulador será invocado, permitindo que você lide com a situação de maneira adequada.

Considere o seguinte trecho de código:

import signal

# Register a signal handler for the timeout
def handler(signum, frame):
    print("Forever is over!")
    raise Exception("end of time")

# Define a function that may run for an indetermined time
def loop_forever():
    import time
    while 1:
        print("sec")
        time.sleep(1)

# Register the signal function handler
signal.signal(signal.SIGALRM, handler)

# Define a timeout for the function
signal.alarm(10)

try:
    loop_forever()
except Exception as exc:
    print(exc)

# Cancel the timer if the function returned before timeout
signal.alarm(0)

Neste exemplo, registramos a função manipuladora para tratar o sinal de tempo limite. Em seguida, definimos nossa função loop_forever de longa duração, que imprime continuamente a mensagem "sec" a cada segundo.

Depois de definir um tempo limite de 10 segundos usando signal.alarm(10), tentamos executar loop_forever. Se a função demorar mais de 10 segundos para ser executada, nosso manipulador de sinal será invocado, exibindo "Forever is over!" e gerando uma exceção.

Para garantir o tratamento adequado do cenário de tempo limite, é essencial cancelar o cronômetro se a função retornar antes do tempo especificado. Em nosso exemplo, chamamos signal.alarm(0) para cancelar o cronômetro quando a exceção é gerada.

Observe que o pacote de sinal pode não interagir bem com ambientes multithread. Além disso, se uma função capturar e ignorar exceções levantadas durante o tempo limite, o mecanismo de tempo limite pode não ser eficaz.