如何实现基于事件的定时器？循环超时退出问题求助

Hey there! Let's break down your problems step by step—first fixing that stubborn loop that won't exit on timeout, then tackling the event-based timer implementation.

1. Fixing the Loop That Fails to Exit on Timeout #

The most likely culprit here is that your code either isn't consistently checking if the timeout has passed, or your packet-receiving operation is blocking indefinitely, preventing the loop from ever getting to the timeout check. Here are two common fixes based on your setup:

Scenario A: Your Receive Function Supports Timeouts #

If your packet-receiving method (like a socket's recv call) lets you set a short timeout, you can structure the loop to check both the packet arrival and the timeout condition on every iteration:

import time

# Set end time as current time + 10 seconds
timeout_deadline = time.time() + 10

while True:
    # First, check if we've already timed out
    if time.time() > timeout_deadline:
        print("Timer expired—exiting loop")
        break
    
    # Try to receive a packet with a short timeout (avoids blocking forever)
    try:
        packet = receive_packet(timeout=0.1)  # Assume this accepts a timeout param
        if packet:
            print("Received packet—exiting loop")
            break
    except TimeoutError:
        # No packet received in the short window, loop back to check timeout
        continue

Scenario B: Your Receive Operation Is Blocking (No Built-In Timeout) #

If your packet receiver is fully blocking (e.g., reading from a hardware interface that doesn't support timeouts), use a thread to handle reception separately, so your main loop can check the timeout without being blocked:

import time
import threading

packet_received_flag = False

def receive_packet_in_thread():
    global packet_received_flag
    # Blocking call to get the packet
    incoming_packet = blocking_receive_packet()
    packet_received_flag = True

# Start the receiver thread (daemon=True ensures it exits with the main program)
threading.Thread(target=receive_packet_in_thread, daemon=True).start()

timeout_deadline = time.time() + 10
while True:
    if packet_received_flag:
        print("Packet received—exiting loop")
        break
    if time.time() > timeout_deadline:
        print("Timer expired—exiting loop")
        break
    time.sleep(0.1)  # Prevent CPU from spinning unnecessarily

2. Implementing an Event-Based Timer #

Event-based timers work by integrating with an event loop—instead of polling the time constantly, the loop triggers a callback when the timeout is reached. Here are two practical implementations:

Option 1: Asyncio (Python's Asynchronous Event Loop) #

For modern Python code, asyncio is the standard for event-driven programming. You can run both the packet receiver and timer as tasks, then wait for either to complete:

import asyncio

async def async_packet_receiver():
    # Example: Async socket connection and packet read
    reader, writer = await asyncio.open_connection("localhost", 8888)
    packet = await reader.read(1024)
    print("Received packet via asyncio")
    writer.close()
    await writer.wait_closed()
    return packet

async def timeout_callback():
    await asyncio.sleep(10)
    print("Event-based timer expired")
    # Trigger loop exit by raising a cancellation error
    raise asyncio.CancelledError

async def main():
    # Create tasks for both operations
    receive_task = asyncio.create_task(async_packet_receiver())
    timer_task = asyncio.create_task(timeout_callback())

    try:
        # Wait for either task to finish first
        done, pending = await asyncio.wait(
            [receive_task, timer_task],
            return_when=asyncio.FIRST_COMPLETED
        )
        # Cancel any unfinished tasks
        for task in pending:
            task.cancel()
    except asyncio.CancelledError:
        pass

asyncio.run(main())

Option 2: Select/Poll (For Synchronous Socket Programming) #

If you're using traditional synchronous sockets, the select module lets you listen for socket events while setting a timeout—this is a lightweight event-driven approach:

import select
import socket

def event_driven_socket_handler():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect(("localhost", 8888))

    while True:
        # Wait up to 10 seconds for the socket to become readable
        ready_sockets, _, _ = select.select([sock], [], [], 10)
        
        if ready_sockets:
            # Socket has data—receive the packet
            packet = sock.recv(1024)
            print("Received packet via select")
            break
        else:
            # Select timed out after 10 seconds
            print("Event-based timer expired via select")
            break
    sock.close()

event_driven_socket_handler()

Key Takeaways #

• Avoid indefinite blocking: Always add timeouts to receive operations or offload blocking work to threads, so your loop can check for timeouts.
• Event-based timers are more efficient: They eliminate busy waiting and integrate cleanly with event-driven architectures, which is ideal for network or IO-heavy code.

内容的提问来源于stack exchange，提问作者Yash Tibrewal