TimeoutQueue.py
Chris Liechti
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.
>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 <clie...@gmx.net>
Tim Peters
> Anyone ever needed a Queue with timeout?
Yes. I encourage you to submit a patch to SourceForge, adding optional
timeout arguments to the std Queue module (include the requisite doc changes
and test suite changes too, and I'll secretly ram it in <wink>). Queue was
written long before threading.py, and, as you noticed, the blocking
operations in threading.py generally do support optional timeouts. They're
a Good Idea for all blocking operations.
Gerhard Häring
> [Chris Liechti]
> > Anyone ever needed a Queue with timeout?
>
I like it. It would certainly be a useful addition.
Gerhard
--
mail: gerhard <at> bigfoot <dot> de registered Linux user #64239
web: http://www.cs.fhm.edu/~ifw00065/ OpenPGP public key id AD24C930
public key fingerprint: 3FCC 8700 3012 0A9E B0C9 3667 814B 9CAA AD24 C930
reduce(lambda x,y:x+y,map(lambda x:chr(ord(x)^42),tuple('zS^BED\nX_FOY\x0b')))
Chris Liechti
news:mailman.1024698810...@python.org:
> [Chris Liechti]
>> Anyone ever needed a Queue with timeout?
>
> Yes. I encourage you to submit a patch to SourceForge, ...
patch 572628 :-) that one uses additional 'timeout' args to get() and new
to put() too. the old behaviour is still maintained when not using the new
argument (unlike the original post which was not backwards compatible).
chris
--
Chris <clie...@gmx.net>
Ype Kingma
Tim Peters wrote:
>
> [Chris Liechti]
> > Anyone ever needed a Queue with timeout?
Yes, and I found a solution for jython, see below.
> Yes. I encourage you to submit a patch to SourceForge, adding optional
> timeout arguments to the std Queue module (include the requisite doc changes
> and test suite changes too, and I'll secretly ram it in <wink>). Queue was
> written long before threading.py, and, as you noticed, the blocking
> operations in threading.py generally do support optional timeouts. They're
> a Good Idea for all blocking operations.
For jython users: a queue with timeout on get() and put() operations
was done by Doug Lea in his util.concurrent java package. See:
http://aspn.activestate.com/ASPN/Mail/Message/Jython-users/828840
for a python interface to this package.
Btw. I would expect Chris' patch to work in jython, too.
Chris, did you add a timeout to the put() method as well?
Regards,
Ype
--
email at xs4all.nl
Chris Liechti
news:3D1624E8...@accessforall.nl:
i think yes, it only needs time.time and time.sleep
> Chris, did you add a timeout to the put() method as well?
in the patch, yes.
chris
--
Chris <clie...@gmx.net>