TimeoutQueue.py

[Chris Liechti]

Anyone ever needed a Queue with timeout?
I have some external hardware, talking over pyserial to my app. The app 
uses threads, i.e one is listening on the serial port, any thread can
send data but receives answers from the listening one using a Queue.
Now sometimes the hardware does not respond (e.g. switched off etc.) and 
the sending thread would be waiting forever in a Queue.get(). Therefore i 
needed a get(timeout) so that i can raise an exception in cas of a hardware 
failure.
I hacked up a version of Queue to TimeoutQueue and attached it for everyone 
who's interested. Its basicaly a merge between Queue.py and threading.py's 
_Event.wait().

have fun,
chris


----- file: TimeoutQueue.py -------------
"""A multi-producer, multi-consumer queue.

now with timeout value for get(). it waits up to 'timeout' seconds
and return the item if one is available within that time or it raises
an Empty exception otherwise.

cliechti at gmx.net
"""

>from time import time as _time, sleep as _sleep

class Empty(Exception):
    "Exception raised by Queue.get(block=0)/get_nowait()."
    pass

class Full(Exception):
    "Exception raised by Queue.put(block=0)/put_nowait()."
    pass

class Queue:
    def __init__(self, maxsize=0):
        """Initialize a queue object with a given maximum size.

        If maxsize is <= 0, the queue size is infinite.
        """
        import thread
        self._init(maxsize)
        self.mutex = thread.allocate_lock()
        self.esema = thread.allocate_lock()
        self.esema.acquire()
        self.fsema = thread.allocate_lock()

    def qsize(self):
        """Return the approximate size of the queue (not reliable!)."""
        self.mutex.acquire()
        n = self._qsize()
        self.mutex.release()
        return n

    def empty(self):
        """Return 1 if the queue is empty, 0 otherwise (not reliable!)."""
        self.mutex.acquire()
        n = self._empty()
        self.mutex.release()
        return n

    def full(self):
        """Return 1 if the queue is full, 0 otherwise (not reliable!)."""
        self.mutex.acquire()
        n = self._full()
        self.mutex.release()
        return n

    def put(self, item, block=1):
        """Put an item into the queue.

        If optional arg 'block' is 1 (the default), block if
        necessary until a free slot is available.  Otherwise (block
        is 0), put an item on the queue if a free slot is immediately
        available, else raise the Full exception.
        """
        if block:
            self.fsema.acquire()
        elif not self.fsema.acquire(0):
            raise Full
        self.mutex.acquire()
        was_empty = self._empty()
        self._put(item)
        if was_empty:
            self.esema.release()
        if not self._full():
            self.fsema.release()
        self.mutex.release()

    def put_nowait(self, item):
        """Put an item into the queue without blocking.

        Only enqueue the item if a free slot is immediately available.
        Otherwise raise the Full exception.
        """
        return self.put(item, 0)

    def get(self, timeout=None):
        """Remove and return an item from the queue.

        If optional arg 'timout' is None (the default), block if
        necessary until an item is available.  Otherwise (timout is a
        number), return an item if one is available within the specified
        time, else raise the Empty exception.
        """
        if timeout is None:
            self.esema.acquire()
        else:
            # code from threading.py: _Event.wait()
            # Balancing act:  We can't afford a pure busy loop, so we
            # have to sleep; but if we sleep the whole timeout time,
            # we'll be unresponsive.  The scheme here sleeps very
            # little at first, longer as time goes on, but never longer
            # than 20 times per second (or the timeout time remaining).
            delay = 0.0005 # 500 us -> initial delay of 1 ms
            endtime = _time() + timeout
            while 1:
                if self.esema.acquire(0):
                    break
                remaining = endtime - _time()
                if remaining <= 0:  #time is over and no element arrived
                    raise Empty
                delay = min(delay * 2, remaining, .05)
                _sleep(delay)       #reduce CPU usage by using a sleep
        self.mutex.acquire()
        was_full = self._full()
        item = self._get()
        if was_full:
            self.fsema.release()
        if not self._empty():
            self.esema.release()
        self.mutex.release()
        return item

    def get_nowait(self):
        """Remove and return an item from the queue without blocking.

        Only get an item if one is immediately available.  Otherwise
        raise the Empty exception.
        """
        return self.get(0)

    # Override these methods to implement other queue organizations
    # (e.g. stack or priority queue).
    # These will only be called with appropriate locks held

    # Initialize the queue representation
    def _init(self, maxsize):
        self.maxsize = maxsize
        self.queue = []

    def _qsize(self):
        return len(self.queue)

    # Check whether the queue is empty
    def _empty(self):
        return not self.queue

    # Check whether the queue is full
    def _full(self):
        return self.maxsize > 0 and len(self.queue) == self.maxsize

    # Put a new item in the queue
    def _put(self, item):
        self.queue.append(item)

    # Get an item from the queue
    def _get(self):
        item = self.queue[0]
        del self.queue[0]
        return item

-------------------
-- 
Chris <cliechti at gmx.net>