| # threading.py: |
| # Proposed new threading module, emulating a subset of Java's threading model |
| |
| import sys |
| import time |
| import thread |
| import traceback |
| import StringIO |
| |
| # Rename some stuff so "from threading import *" is safe |
| |
| _sys = sys |
| del sys |
| |
| _time = time.time |
| _sleep = time.sleep |
| del time |
| |
| _start_new_thread = thread.start_new_thread |
| _allocate_lock = thread.allocate_lock |
| _get_ident = thread.get_ident |
| del thread |
| |
| _print_exc = traceback.print_exc |
| del traceback |
| |
| _StringIO = StringIO.StringIO |
| del StringIO |
| |
| |
| # Debug support (adapted from ihooks.py) |
| |
| _VERBOSE = 0 |
| |
| if __debug__: |
| |
| class _Verbose: |
| |
| def __init__(self, verbose=None): |
| if verbose is None: |
| verbose = _VERBOSE |
| self.__verbose = verbose |
| |
| def _note(self, format, *args): |
| if self.__verbose: |
| format = format % args |
| format = "%s: %s\n" % ( |
| currentThread().getName(), format) |
| _sys.stderr.write(format) |
| |
| else: |
| # Disable this when using "python -O" |
| class _Verbose: |
| def __init__(self, verbose=None): |
| pass |
| def _note(self, *args): |
| pass |
| |
| |
| # Synchronization classes |
| |
| Lock = _allocate_lock |
| |
| def RLock(*args, **kwargs): |
| return apply(_RLock, args, kwargs) |
| |
| class _RLock(_Verbose): |
| |
| def __init__(self, verbose=None): |
| _Verbose.__init__(self, verbose) |
| self.__block = _allocate_lock() |
| self.__owner = None |
| self.__count = 0 |
| |
| def __repr__(self): |
| return "<%s(%s, %d)>" % ( |
| self.__class__.__name__, |
| self.__owner and self.__owner.getName(), |
| self.__count) |
| |
| def acquire(self, blocking=1): |
| me = currentThread() |
| if self.__owner is me: |
| self.__count = self.__count + 1 |
| if __debug__: |
| self._note("%s.acquire(%s): recursive success", self, blocking) |
| return 1 |
| rc = self.__block.acquire(blocking) |
| if rc: |
| self.__owner = me |
| self.__count = 1 |
| if __debug__: |
| self._note("%s.acquire(%s): initial succes", self, blocking) |
| else: |
| if __debug__: |
| self._note("%s.acquire(%s): failure", self, blocking) |
| return rc |
| |
| def release(self): |
| me = currentThread() |
| assert self.__owner is me, "release() of un-acquire()d lock" |
| self.__count = count = self.__count - 1 |
| if not count: |
| self.__owner = None |
| self.__block.release() |
| if __debug__: |
| self._note("%s.release(): final release", self) |
| else: |
| if __debug__: |
| self._note("%s.release(): non-final release", self) |
| |
| # Internal methods used by condition variables |
| |
| def _acquire_restore(self, (count, owner)): |
| self.__block.acquire() |
| self.__count = count |
| self.__owner = owner |
| if __debug__: |
| self._note("%s._acquire_restore()", self) |
| |
| def _release_save(self): |
| if __debug__: |
| self._note("%s._release_save()", self) |
| count = self.__count |
| self.__count = 0 |
| owner = self.__owner |
| self.__owner = None |
| self.__block.release() |
| return (count, owner) |
| |
| def _is_owned(self): |
| return self.__owner is currentThread() |
| |
| |
| def Condition(*args, **kwargs): |
| return apply(_Condition, args, kwargs) |
| |
| class _Condition(_Verbose): |
| |
| def __init__(self, lock=None, verbose=None): |
| _Verbose.__init__(self, verbose) |
| if lock is None: |
| lock = RLock() |
| self.__lock = lock |
| # Export the lock's acquire() and release() methods |
| self.acquire = lock.acquire |
| self.release = lock.release |
| # If the lock defines _release_save() and/or _acquire_restore(), |
| # these override the default implementations (which just call |
| # release() and acquire() on the lock). Ditto for _is_owned(). |
| try: |
| self._release_save = lock._release_save |
| except AttributeError: |
| pass |
| try: |
| self._acquire_restore = lock._acquire_restore |
| except AttributeError: |
| pass |
| try: |
| self._is_owned = lock._is_owned |
| except AttributeError: |
| pass |
| self.__waiters = [] |
| |
| def __repr__(self): |
| return "<Condition(%s, %d)>" % (self.__lock, len(self.__waiters)) |
| |
| def _release_save(self): |
| self.__lock.release() # No state to save |
| |
| def _acquire_restore(self, x): |
| self.__lock.acquire() # Ignore saved state |
| |
| def _is_owned(self): |
| if self.__lock.acquire(0): |
| self.__lock.release() |
| return 0 |
| else: |
| return 1 |
| |
| def wait(self, timeout=None): |
| me = currentThread() |
| assert self._is_owned(), "wait() of un-acquire()d lock" |
| waiter = _allocate_lock() |
| waiter.acquire() |
| self.__waiters.append(waiter) |
| saved_state = self._release_save() |
| if timeout is None: |
| waiter.acquire() |
| if __debug__: |
| self._note("%s.wait(): got it", self) |
| else: |
| endtime = _time() + timeout |
| delay = 0.000001 # 1 usec |
| while 1: |
| gotit = waiter.acquire(0) |
| if gotit or _time() >= endtime: |
| break |
| _sleep(delay) |
| if delay < 1.0: |
| delay = delay * 2.0 |
| if not gotit: |
| if __debug__: |
| self._note("%s.wait(%s): timed out", self, timeout) |
| try: |
| self.__waiters.remove(waiter) |
| except ValueError: |
| pass |
| else: |
| if __debug__: |
| self._note("%s.wait(%s): got it", self, timeout) |
| self._acquire_restore(saved_state) |
| |
| def notify(self, n=1): |
| me = currentThread() |
| assert self._is_owned(), "notify() of un-acquire()d lock" |
| __waiters = self.__waiters |
| waiters = __waiters[:n] |
| if not waiters: |
| if __debug__: |
| self._note("%s.notify(): no waiters", self) |
| return |
| self._note("%s.notify(): notifying %d waiter%s", self, n, |
| n!=1 and "s" or "") |
| for waiter in waiters: |
| waiter.release() |
| try: |
| __waiters.remove(waiter) |
| except ValueError: |
| pass |
| |
| def notifyAll(self): |
| self.notify(len(self.__waiters)) |
| |
| |
| def Semaphore(*args, **kwargs): |
| return apply(_Semaphore, args, kwargs) |
| |
| class _Semaphore(_Verbose): |
| |
| # After Tim Peters' semaphore class, but bnot quite the same (no maximum) |
| |
| def __init__(self, value=1, verbose=None): |
| assert value >= 0, "Semaphore initial value must be >= 0" |
| _Verbose.__init__(self, verbose) |
| self.__cond = Condition(Lock()) |
| self.__value = value |
| |
| def acquire(self, blocking=1): |
| rc = 0 |
| self.__cond.acquire() |
| while self.__value == 0: |
| if not blocking: |
| break |
| self.__cond.wait() |
| else: |
| self.__value = self.__value - 1 |
| rc = 1 |
| self.__cond.release() |
| return rc |
| |
| def release(self): |
| self.__cond.acquire() |
| self.__value = self.__value + 1 |
| self.__cond.notify() |
| self.__cond.release() |
| |
| |
| def Event(*args, **kwargs): |
| return apply(_Event, args, kwargs) |
| |
| class _Event(_Verbose): |
| |
| # After Tim Peters' event class (without is_posted()) |
| |
| def __init__(self, verbose=None): |
| _Verbose.__init__(self, verbose) |
| self.__cond = Condition(Lock()) |
| self.__flag = 0 |
| |
| def isSet(self): |
| return self.__flag |
| |
| def set(self): |
| self.__cond.acquire() |
| self.__flag = 1 |
| self.__cond.notifyAll() |
| self.__cond.release() |
| |
| def clear(self): |
| self.__cond.acquire() |
| self.__flag = 0 |
| self.__cond.release() |
| |
| def wait(self, timeout=None): |
| self.__cond.acquire() |
| if not self.__flag: |
| self.__cond.wait(timeout) |
| self.__cond.release() |
| |
| |
| # Helper to generate new thread names |
| _counter = 0 |
| def _newname(template="Thread-%d"): |
| global _counter |
| _counter = _counter + 1 |
| return template % _counter |
| |
| # Active thread administration |
| _active_limbo_lock = _allocate_lock() |
| _active = {} |
| _limbo = {} |
| |
| |
| # Main class for threads |
| |
| class Thread(_Verbose): |
| |
| __initialized = 0 |
| |
| def __init__(self, group=None, target=None, name=None, |
| args=(), kwargs={}, verbose=None): |
| assert group is None, "group argument must be None for now" |
| _Verbose.__init__(self, verbose) |
| self.__target = target |
| self.__name = str(name or _newname()) |
| self.__args = args |
| self.__kwargs = kwargs |
| self.__daemonic = self._set_daemon() |
| self.__started = 0 |
| self.__stopped = 0 |
| self.__block = Condition(Lock()) |
| self.__initialized = 1 |
| |
| def _set_daemon(self): |
| # Overridden in _MainThread and _DummyThread |
| return currentThread().isDaemon() |
| |
| def __repr__(self): |
| assert self.__initialized, "Thread.__init__() was not called" |
| status = "initial" |
| if self.__started: |
| status = "started" |
| if self.__stopped: |
| status = "stopped" |
| if self.__daemonic: |
| status = status + " daemon" |
| return "<%s(%s, %s)>" % (self.__class__.__name__, self.__name, status) |
| |
| def start(self): |
| assert self.__initialized, "Thread.__init__() not called" |
| assert not self.__started, "thread already started" |
| if __debug__: |
| self._note("%s.start(): starting thread", self) |
| _active_limbo_lock.acquire() |
| _limbo[self] = self |
| _active_limbo_lock.release() |
| _start_new_thread(self.__bootstrap, ()) |
| self.__started = 1 |
| _sleep(0.000001) # 1 usec, to let the thread run (Solaris hack) |
| |
| def run(self): |
| if self.__target: |
| apply(self.__target, self.__args, self.__kwargs) |
| |
| def __bootstrap(self): |
| try: |
| self.__started = 1 |
| _active_limbo_lock.acquire() |
| _active[_get_ident()] = self |
| del _limbo[self] |
| _active_limbo_lock.release() |
| if __debug__: |
| self._note("%s.__bootstrap(): thread started", self) |
| try: |
| self.run() |
| except SystemExit: |
| if __debug__: |
| self._note("%s.__bootstrap(): raised SystemExit", self) |
| except: |
| if __debug__: |
| self._note("%s.__bootstrap(): unhandled exception", self) |
| s = _StringIO() |
| _print_exc(file=s) |
| _sys.stderr.write("Exception in thread %s:\n%s\n" % |
| (self.getName(), s.getvalue())) |
| else: |
| if __debug__: |
| self._note("%s.__bootstrap(): normal return", self) |
| finally: |
| self.__stop() |
| self.__delete() |
| |
| def __stop(self): |
| self.__block.acquire() |
| self.__stopped = 1 |
| self.__block.notifyAll() |
| self.__block.release() |
| |
| def __delete(self): |
| _active_limbo_lock.acquire() |
| del _active[_get_ident()] |
| _active_limbo_lock.release() |
| |
| def join(self, timeout=None): |
| assert self.__initialized, "Thread.__init__() not called" |
| assert self.__started, "cannot join thread before it is started" |
| assert self is not currentThread(), "cannot join current thread" |
| if __debug__: |
| if not self.__stopped: |
| self._note("%s.join(): waiting until thread stops", self) |
| self.__block.acquire() |
| if timeout is None: |
| while not self.__stopped: |
| self.__block.wait() |
| if __debug__: |
| self._note("%s.join(): thread stopped", self) |
| else: |
| deadline = _time() + timeout |
| while not self.__stopped: |
| delay = deadline - _time() |
| if delay <= 0: |
| if __debug__: |
| self._note("%s.join(): timed out", self) |
| break |
| self.__block.wait(delay) |
| else: |
| if __debug__: |
| self._note("%s.join(): thread stopped", self) |
| self.__block.release() |
| |
| def getName(self): |
| assert self.__initialized, "Thread.__init__() not called" |
| return self.__name |
| |
| def setName(self, name): |
| assert self.__initialized, "Thread.__init__() not called" |
| self.__name = str(name) |
| |
| def isAlive(self): |
| assert self.__initialized, "Thread.__init__() not called" |
| return self.__started and not self.__stopped |
| |
| def isDaemon(self): |
| assert self.__initialized, "Thread.__init__() not called" |
| return self.__daemonic |
| |
| def setDaemon(self, daemonic): |
| assert self.__initialized, "Thread.__init__() not called" |
| assert not self.__started, "cannot set daemon status of active thread" |
| self.__daemonic = daemonic |
| |
| |
| # Special thread class to represent the main thread |
| # This is garbage collected through an exit handler |
| |
| class _MainThread(Thread): |
| |
| def __init__(self): |
| Thread.__init__(self, name="MainThread") |
| self._Thread__started = 1 |
| _active_limbo_lock.acquire() |
| _active[_get_ident()] = self |
| _active_limbo_lock.release() |
| try: |
| self.__oldexitfunc = _sys.exitfunc |
| except AttributeError: |
| self.__oldexitfunc = None |
| _sys.exitfunc = self.__exitfunc |
| |
| def _set_daemon(self): |
| return 0 |
| |
| def __exitfunc(self): |
| self._Thread__stop() |
| t = _pickSomeNonDaemonThread() |
| if t: |
| if __debug__: |
| self._note("%s: waiting for other threads", self) |
| while t: |
| t.join() |
| t = _pickSomeNonDaemonThread() |
| if self.__oldexitfunc: |
| if __debug__: |
| self._note("%s: calling exit handler", self) |
| self.__oldexitfunc() |
| if __debug__: |
| self._note("%s: exiting", self) |
| self._Thread__delete() |
| |
| def _pickSomeNonDaemonThread(): |
| for t in enumerate(): |
| if not t.isDaemon() and t.isAlive(): |
| return t |
| return None |
| |
| |
| # Dummy thread class to represent threads not started here. |
| # These aren't garbage collected when they die, |
| # nor can they be waited for. |
| # Their purpose is to return *something* from currentThread(). |
| # They are marked as daemon threads so we won't wait for them |
| # when we exit (conform previous semantics). |
| |
| class _DummyThread(Thread): |
| |
| def __init__(self): |
| Thread.__init__(self, name=_newname("Dummy-%d")) |
| self.__Thread_started = 1 |
| _active_limbo_lock.acquire() |
| _active[_get_ident()] = self |
| _active_limbo_lock.release() |
| |
| def _set_daemon(self): |
| return 1 |
| |
| def join(self): |
| assert 0, "cannot join a dummy thread" |
| |
| |
| # Global API functions |
| |
| def currentThread(): |
| try: |
| return _active[_get_ident()] |
| except KeyError: |
| print "currentThread(): no current thread for", _get_ident() |
| return _DummyThread() |
| |
| def activeCount(): |
| _active_limbo_lock.acquire() |
| count = len(_active) + len(_limbo) |
| _active_limbo_lock.release() |
| return count |
| |
| def enumerate(): |
| _active_limbo_lock.acquire() |
| active = _active.values() + _limbo.values() |
| _active_limbo_lock.release() |
| return active |
| |
| |
| # Create the main thread object |
| |
| _MainThread() |
| |
| |
| # Self-test code |
| |
| def _test(): |
| |
| import random |
| |
| class BoundedQueue(_Verbose): |
| |
| def __init__(self, limit): |
| _Verbose.__init__(self) |
| self.mon = RLock() |
| self.rc = Condition(self.mon) |
| self.wc = Condition(self.mon) |
| self.limit = limit |
| self.queue = [] |
| |
| def put(self, item): |
| self.mon.acquire() |
| while len(self.queue) >= self.limit: |
| self._note("put(%s): queue full", item) |
| self.wc.wait() |
| self.queue.append(item) |
| self._note("put(%s): appended, length now %d", |
| item, len(self.queue)) |
| self.rc.notify() |
| self.mon.release() |
| |
| def get(self): |
| self.mon.acquire() |
| while not self.queue: |
| self._note("get(): queue empty") |
| self.rc.wait() |
| item = self.queue[0] |
| del self.queue[0] |
| self._note("get(): got %s, %d left", item, len(self.queue)) |
| self.wc.notify() |
| self.mon.release() |
| return item |
| |
| class ProducerThread(Thread): |
| |
| def __init__(self, queue, quota): |
| Thread.__init__(self, name="Producer") |
| self.queue = queue |
| self.quota = quota |
| |
| def run(self): |
| from random import random |
| counter = 0 |
| while counter < self.quota: |
| counter = counter + 1 |
| self.queue.put("%s.%d" % (self.getName(), counter)) |
| _sleep(random() * 0.00001) |
| |
| |
| class ConsumerThread(Thread): |
| |
| def __init__(self, queue, count): |
| Thread.__init__(self, name="Consumer") |
| self.queue = queue |
| self.count = count |
| |
| def run(self): |
| while self.count > 0: |
| item = self.queue.get() |
| print item |
| self.count = self.count - 1 |
| |
| import time |
| |
| NP = 3 |
| QL = 4 |
| NI = 5 |
| |
| Q = BoundedQueue(QL) |
| P = [] |
| for i in range(NP): |
| t = ProducerThread(Q, NI) |
| t.setName("Producer-%d" % (i+1)) |
| P.append(t) |
| C = ConsumerThread(Q, NI*NP) |
| for t in P: |
| t.start() |
| _sleep(0.000001) |
| C.start() |
| for t in P: |
| t.join() |
| C.join() |
| |
| if __name__ == '__main__': |
| _test() |