Timeout on a function call

Navigating the timeout sea: Different strategies

When the simplicity of signal-based timeouts isn't cutting the cheese (maybe you're on Windows or in a multi-threaded program), multiprocessing and threading are your next ports of call. They might be a bit fussy, but they get the job done everywhere.

Multiprocessing: The strong, silent type

For tasks that go to town on your CPU, multiprocessing can strap a time bomb on 'em for a dramatic finish:

from multiprocessing import Process

def my_func():
    # CPU's worst nightmare here

p = Process(target=my_func)
p.start()
p.join(timeout=5)  # 5 seconds: the time it takes to make an instant noodle soup

if p.is_alive():
    p.terminate()  # Too slow, my_func. You're terminated.


Terminate or even kill a process that hangs around after the timeout. Ah! The sweet aroma of platform independence.

Thread pooling: The smooth operator

For I/O-bound tasks or those lightweight CPU-bound tasks fixin' for some multitasking, a ThreadPool ain't gonna break a sweat:

from multiprocessing.pool import ThreadPool

pool = ThreadPool(processes=1)  # Pool party of 1: Multi-threading rumor debunked. 
async_result = pool.apply_async(my_func)  # Async's underappreciated magic trick

try:
    output = async_result.get(timeout=5)  # Value loaded in 5 secs, or your money back.
except TimeoutError:
    print("Timeout is such a showstopper!")


Decorators: The Fairy Godmother of timeouts

Want a timeout wand that can touch any function and turn it into a timed model? Use the magic word—decorator:

from functools import wraps
import errno
import os
from threading import Timer

def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):
    def decorator(func):
        @wraps(func)
        def _handle_timeout(*args, **kwargs):
            timer = Timer(seconds, lambda: raise_timeout())  # Hey! No I'm not a cooking timer.
            timer.start()  # Here I go... 
            try:
                result = func(*args, **kwargs)
            finally:
                timer.cancel()  # Job's done. Time for a snack.
            return result
        return _handle_timeout
    return decorator

@timeout(5)  # Wrap me around my_func and I won't let it slack!
def my_func():
    # Your procrastinating function


Wrap this timeout decorator around any function, and you've got yourself a time-governed function. Feels like the future of multi-threading, right?

A timeout toolkit: Special scenarios and pitfalls

When using timeouts, remember, with great power comes great responsibility. There's no one-size-fits-all solution. Be wary of potential quirks and speed-bumps!

Threading and responsiveness: A delicate balance

Multi-threaded operations handle timeouts differently. Use flags and exception handling to arm yourself against unresponsive threads:

def my_func(stop_event):
    while not stop_event.is_set():
        # Operation amidst ticking wall clock 


Python version compatibility: Playing fair

Ensure your solution is a good sport with different Python versions. Make your scratches into multiprocessing or threading modules backward-compatible.

Post-timeout actions: The understudy

Sometimes the show must go on, even if the star (main function) couldn't make it till the end:

try:
    my_func()
except TimeoutError:
    alternative_func()  # Go on, no pressure. You've been rehearsing all night!


Unforeseen termination: The wild card

Forceful process or thread termination might leave loose ends in your program. Always tie up those unhandled resources or data!