| """Thread module emulating a subset of Java's threading model.""" | |
| import sys as _sys | |
| try: | |
| import thread | |
| except ImportError: | |
| del _sys.modules[__name__] | |
| raise | |
| import warnings | |
| from collections import deque as _deque | |
| from itertools import count as _count | |
| from time import time as _time, sleep as _sleep | |
| from traceback import format_exc as _format_exc | |
| # Note regarding PEP 8 compliant aliases | |
| # This threading model was originally inspired by Java, and inherited | |
| # the convention of camelCase function and method names from that | |
| # language. While those names are not in any imminent danger of being | |
| # deprecated, starting with Python 2.6, the module now provides a | |
| # PEP 8 compliant alias for any such method name. | |
| # Using the new PEP 8 compliant names also facilitates substitution | |
| # with the multiprocessing module, which doesn't provide the old | |
| # Java inspired names. | |
| # Rename some stuff so "from threading import *" is safe | |
| __all__ = ['activeCount', 'active_count', 'Condition', 'currentThread', | |
| 'current_thread', 'enumerate', 'Event', | |
| 'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread', | |
| 'Timer', 'setprofile', 'settrace', 'local', 'stack_size'] | |
| _start_new_thread = thread.start_new_thread | |
| _allocate_lock = thread.allocate_lock | |
| _get_ident = thread.get_ident | |
| ThreadError = thread.error | |
| del thread | |
| # sys.exc_clear is used to work around the fact that except blocks | |
| # don't fully clear the exception until 3.0. | |
| warnings.filterwarnings('ignore', category=DeprecationWarning, | |
| module='threading', message='sys.exc_clear') | |
| # Debug support (adapted from ihooks.py). | |
| # All the major classes here derive from _Verbose. We force that to | |
| # be a new-style class so that all the major classes here are new-style. | |
| # This helps debugging (type(instance) is more revealing for instances | |
| # of new-style classes). | |
| _VERBOSE = False | |
| if __debug__: | |
| class _Verbose(object): | |
| 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 | |
| # Issue #4188: calling current_thread() can incur an infinite | |
| # recursion if it has to create a DummyThread on the fly. | |
| ident = _get_ident() | |
| try: | |
| name = _active[ident].name | |
| except KeyError: | |
| name = "<OS thread %d>" % ident | |
| format = "%s: %s\n" % (name, format) | |
| _sys.stderr.write(format) | |
| else: | |
| # Disable this when using "python -O" | |
| class _Verbose(object): | |
| def __init__(self, verbose=None): | |
| pass | |
| def _note(self, *args): | |
| pass | |
| # Support for profile and trace hooks | |
| _profile_hook = None | |
| _trace_hook = None | |
| def setprofile(func): | |
| """Set a profile function for all threads started from the threading module. | |
| The func will be passed to sys.setprofile() for each thread, before its | |
| run() method is called. | |
| """ | |
| global _profile_hook | |
| _profile_hook = func | |
| def settrace(func): | |
| """Set a trace function for all threads started from the threading module. | |
| The func will be passed to sys.settrace() for each thread, before its run() | |
| method is called. | |
| """ | |
| global _trace_hook | |
| _trace_hook = func | |
| # Synchronization classes | |
| Lock = _allocate_lock | |
| def RLock(*args, **kwargs): | |
| """Factory function that returns a new reentrant lock. | |
| A reentrant lock must be released by the thread that acquired it. Once a | |
| thread has acquired a reentrant lock, the same thread may acquire it again | |
| without blocking; the thread must release it once for each time it has | |
| acquired it. | |
| """ | |
| return _RLock(*args, **kwargs) | |
| class _RLock(_Verbose): | |
| """A reentrant lock must be released by the thread that acquired it. Once a | |
| thread has acquired a reentrant lock, the same thread may acquire it | |
| again without blocking; the thread must release it once for each time it | |
| has acquired it. | |
| """ | |
| def __init__(self, verbose=None): | |
| _Verbose.__init__(self, verbose) | |
| self.__block = _allocate_lock() | |
| self.__owner = None | |
| self.__count = 0 | |
| def __repr__(self): | |
| owner = self.__owner | |
| try: | |
| owner = _active[owner].name | |
| except KeyError: | |
| pass | |
| return "<%s owner=%r count=%d>" % ( | |
| self.__class__.__name__, owner, self.__count) | |
| def acquire(self, blocking=1): | |
| """Acquire a lock, blocking or non-blocking. | |
| When invoked without arguments: if this thread already owns the lock, | |
| increment the recursion level by one, and return immediately. Otherwise, | |
| if another thread owns the lock, block until the lock is unlocked. Once | |
| the lock is unlocked (not owned by any thread), then grab ownership, set | |
| the recursion level to one, and return. If more than one thread is | |
| blocked waiting until the lock is unlocked, only one at a time will be | |
| able to grab ownership of the lock. There is no return value in this | |
| case. | |
| When invoked with the blocking argument set to true, do the same thing | |
| as when called without arguments, and return true. | |
| When invoked with the blocking argument set to false, do not block. If a | |
| call without an argument would block, return false immediately; | |
| otherwise, do the same thing as when called without arguments, and | |
| return true. | |
| """ | |
| me = _get_ident() | |
| if self.__owner == 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 success", self, blocking) | |
| else: | |
| if __debug__: | |
| self._note("%s.acquire(%s): failure", self, blocking) | |
| return rc | |
| __enter__ = acquire | |
| def release(self): | |
| """Release a lock, decrementing the recursion level. | |
| If after the decrement it is zero, reset the lock to unlocked (not owned | |
| by any thread), and if any other threads are blocked waiting for the | |
| lock to become unlocked, allow exactly one of them to proceed. If after | |
| the decrement the recursion level is still nonzero, the lock remains | |
| locked and owned by the calling thread. | |
| Only call this method when the calling thread owns the lock. A | |
| RuntimeError is raised if this method is called when the lock is | |
| unlocked. | |
| There is no return value. | |
| """ | |
| if self.__owner != _get_ident(): | |
| raise RuntimeError("cannot release un-acquired 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) | |
| def __exit__(self, t, v, tb): | |
| self.release() | |
| # Internal methods used by condition variables | |
| def _acquire_restore(self, count_owner): | |
| count, owner = 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 == _get_ident() | |
| def Condition(*args, **kwargs): | |
| """Factory function that returns a new condition variable object. | |
| A condition variable allows one or more threads to wait until they are | |
| notified by another thread. | |
| If the lock argument is given and not None, it must be a Lock or RLock | |
| object, and it is used as the underlying lock. Otherwise, a new RLock object | |
| is created and used as the underlying lock. | |
| """ | |
| return _Condition(*args, **kwargs) | |
| class _Condition(_Verbose): | |
| """Condition variables allow one or more threads to wait until they are | |
| notified by another thread. | |
| """ | |
| 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 __enter__(self): | |
| return self.__lock.__enter__() | |
| def __exit__(self, *args): | |
| return self.__lock.__exit__(*args) | |
| 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): | |
| # Return True if lock is owned by current_thread. | |
| # This method is called only if __lock doesn't have _is_owned(). | |
| if self.__lock.acquire(0): | |
| self.__lock.release() | |
| return False | |
| else: | |
| return True | |
| def wait(self, timeout=None): | |
| """Wait until notified or until a timeout occurs. | |
| If the calling thread has not acquired the lock when this method is | |
| called, a RuntimeError is raised. | |
| This method releases the underlying lock, and then blocks until it is | |
| awakened by a notify() or notifyAll() call for the same condition | |
| variable in another thread, or until the optional timeout occurs. Once | |
| awakened or timed out, it re-acquires the lock and returns. | |
| When the timeout argument is present and not None, it should be a | |
| floating point number specifying a timeout for the operation in seconds | |
| (or fractions thereof). | |
| When the underlying lock is an RLock, it is not released using its | |
| release() method, since this may not actually unlock the lock when it | |
| was acquired multiple times recursively. Instead, an internal interface | |
| of the RLock class is used, which really unlocks it even when it has | |
| been recursively acquired several times. Another internal interface is | |
| then used to restore the recursion level when the lock is reacquired. | |
| """ | |
| if not self._is_owned(): | |
| raise RuntimeError("cannot wait on un-acquired lock") | |
| waiter = _allocate_lock() | |
| waiter.acquire() | |
| self.__waiters.append(waiter) | |
| saved_state = self._release_save() | |
| try: # restore state no matter what (e.g., KeyboardInterrupt) | |
| if timeout is None: | |
| waiter.acquire() | |
| if __debug__: | |
| self._note("%s.wait(): got it", self) | |
| else: | |
| # 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). | |
| endtime = _time() + timeout | |
| delay = 0.0005 # 500 us -> initial delay of 1 ms | |
| while True: | |
| gotit = waiter.acquire(0) | |
| if gotit: | |
| break | |
| remaining = endtime - _time() | |
| if remaining <= 0: | |
| break | |
| delay = min(delay * 2, remaining, .05) | |
| _sleep(delay) | |
| 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) | |
| finally: | |
| self._acquire_restore(saved_state) | |
| def notify(self, n=1): | |
| """Wake up one or more threads waiting on this condition, if any. | |
| If the calling thread has not acquired the lock when this method is | |
| called, a RuntimeError is raised. | |
| This method wakes up at most n of the threads waiting for the condition | |
| variable; it is a no-op if no threads are waiting. | |
| """ | |
| if not self._is_owned(): | |
| raise RuntimeError("cannot notify on un-acquired 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): | |
| """Wake up all threads waiting on this condition. | |
| If the calling thread has not acquired the lock when this method | |
| is called, a RuntimeError is raised. | |
| """ | |
| self.notify(len(self.__waiters)) | |
| notify_all = notifyAll | |
| def Semaphore(*args, **kwargs): | |
| """A factory function that returns a new semaphore. | |
| Semaphores manage a counter representing the number of release() calls minus | |
| the number of acquire() calls, plus an initial value. The acquire() method | |
| blocks if necessary until it can return without making the counter | |
| negative. If not given, value defaults to 1. | |
| """ | |
| return _Semaphore(*args, **kwargs) | |
| class _Semaphore(_Verbose): | |
| """Semaphores manage a counter representing the number of release() calls | |
| minus the number of acquire() calls, plus an initial value. The acquire() | |
| method blocks if necessary until it can return without making the counter | |
| negative. If not given, value defaults to 1. | |
| """ | |
| # After Tim Peters' semaphore class, but not quite the same (no maximum) | |
| def __init__(self, value=1, verbose=None): | |
| if value < 0: | |
| raise ValueError("semaphore initial value must be >= 0") | |
| _Verbose.__init__(self, verbose) | |
| self.__cond = Condition(Lock()) | |
| self.__value = value | |
| def acquire(self, blocking=1): | |
| """Acquire a semaphore, decrementing the internal counter by one. | |
| When invoked without arguments: if the internal counter is larger than | |
| zero on entry, decrement it by one and return immediately. If it is zero | |
| on entry, block, waiting until some other thread has called release() to | |
| make it larger than zero. This is done with proper interlocking so that | |
| if multiple acquire() calls are blocked, release() will wake exactly one | |
| of them up. The implementation may pick one at random, so the order in | |
| which blocked threads are awakened should not be relied on. There is no | |
| return value in this case. | |
| When invoked with blocking set to true, do the same thing as when called | |
| without arguments, and return true. | |
| When invoked with blocking set to false, do not block. If a call without | |
| an argument would block, return false immediately; otherwise, do the | |
| same thing as when called without arguments, and return true. | |
| """ | |
| rc = False | |
| with self.__cond: | |
| while self.__value == 0: | |
| if not blocking: | |
| break | |
| if __debug__: | |
| self._note("%s.acquire(%s): blocked waiting, value=%s", | |
| self, blocking, self.__value) | |
| self.__cond.wait() | |
| else: | |
| self.__value = self.__value - 1 | |
| if __debug__: | |
| self._note("%s.acquire: success, value=%s", | |
| self, self.__value) | |
| rc = True | |
| return rc | |
| __enter__ = acquire | |
| def release(self): | |
| """Release a semaphore, incrementing the internal counter by one. | |
| When the counter is zero on entry and another thread is waiting for it | |
| to become larger than zero again, wake up that thread. | |
| """ | |
| with self.__cond: | |
| self.__value = self.__value + 1 | |
| if __debug__: | |
| self._note("%s.release: success, value=%s", | |
| self, self.__value) | |
| self.__cond.notify() | |
| def __exit__(self, t, v, tb): | |
| self.release() | |
| def BoundedSemaphore(*args, **kwargs): | |
| """A factory function that returns a new bounded semaphore. | |
| A bounded semaphore checks to make sure its current value doesn't exceed its | |
| initial value. If it does, ValueError is raised. In most situations | |
| semaphores are used to guard resources with limited capacity. | |
| If the semaphore is released too many times it's a sign of a bug. If not | |
| given, value defaults to 1. | |
| Like regular semaphores, bounded semaphores manage a counter representing | |
| the number of release() calls minus the number of acquire() calls, plus an | |
| initial value. The acquire() method blocks if necessary until it can return | |
| without making the counter negative. If not given, value defaults to 1. | |
| """ | |
| return _BoundedSemaphore(*args, **kwargs) | |
| class _BoundedSemaphore(_Semaphore): | |
| """A bounded semaphore checks to make sure its current value doesn't exceed | |
| its initial value. If it does, ValueError is raised. In most situations | |
| semaphores are used to guard resources with limited capacity. | |
| """ | |
| def __init__(self, value=1, verbose=None): | |
| _Semaphore.__init__(self, value, verbose) | |
| self._initial_value = value | |
| def release(self): | |
| """Release a semaphore, incrementing the internal counter by one. | |
| When the counter is zero on entry and another thread is waiting for it | |
| to become larger than zero again, wake up that thread. | |
| If the number of releases exceeds the number of acquires, | |
| raise a ValueError. | |
| """ | |
| with self._Semaphore__cond: | |
| if self._Semaphore__value >= self._initial_value: | |
| raise ValueError("Semaphore released too many times") | |
| self._Semaphore__value += 1 | |
| self._Semaphore__cond.notify() | |
| def Event(*args, **kwargs): | |
| """A factory function that returns a new event. | |
| Events manage a flag that can be set to true with the set() method and reset | |
| to false with the clear() method. The wait() method blocks until the flag is | |
| true. | |
| """ | |
| return _Event(*args, **kwargs) | |
| class _Event(_Verbose): | |
| """A factory function that returns a new event object. An event manages a | |
| flag that can be set to true with the set() method and reset to false | |
| with the clear() method. The wait() method blocks until the flag is true. | |
| """ | |
| # After Tim Peters' event class (without is_posted()) | |
| def __init__(self, verbose=None): | |
| _Verbose.__init__(self, verbose) | |
| self.__cond = Condition(Lock()) | |
| self.__flag = False | |
| def _reset_internal_locks(self): | |
| # private! called by Thread._reset_internal_locks by _after_fork() | |
| self.__cond.__init__(Lock()) | |
| def isSet(self): | |
| 'Return true if and only if the internal flag is true.' | |
| return self.__flag | |
| is_set = isSet | |
| def set(self): | |
| """Set the internal flag to true. | |
| All threads waiting for the flag to become true are awakened. Threads | |
| that call wait() once the flag is true will not block at all. | |
| """ | |
| with self.__cond: | |
| self.__flag = True | |
| self.__cond.notify_all() | |
| def clear(self): | |
| """Reset the internal flag to false. | |
| Subsequently, threads calling wait() will block until set() is called to | |
| set the internal flag to true again. | |
| """ | |
| with self.__cond: | |
| self.__flag = False | |
| def wait(self, timeout=None): | |
| """Block until the internal flag is true. | |
| If the internal flag is true on entry, return immediately. Otherwise, | |
| block until another thread calls set() to set the flag to true, or until | |
| the optional timeout occurs. | |
| When the timeout argument is present and not None, it should be a | |
| floating point number specifying a timeout for the operation in seconds | |
| (or fractions thereof). | |
| This method returns the internal flag on exit, so it will always return | |
| True except if a timeout is given and the operation times out. | |
| """ | |
| with self.__cond: | |
| if not self.__flag: | |
| self.__cond.wait(timeout) | |
| return self.__flag | |
| # Helper to generate new thread names | |
| _counter = _count().next | |
| _counter() # Consume 0 so first non-main thread has id 1. | |
| def _newname(template="Thread-%d"): | |
| return template % _counter() | |
| # Active thread administration | |
| _active_limbo_lock = _allocate_lock() | |
| _active = {} # maps thread id to Thread object | |
| _limbo = {} | |
| # Main class for threads | |
| class Thread(_Verbose): | |
| """A class that represents a thread of control. | |
| This class can be safely subclassed in a limited fashion. | |
| """ | |
| __initialized = False | |
| # Need to store a reference to sys.exc_info for printing | |
| # out exceptions when a thread tries to use a global var. during interp. | |
| # shutdown and thus raises an exception about trying to perform some | |
| # operation on/with a NoneType | |
| __exc_info = _sys.exc_info | |
| # Keep sys.exc_clear too to clear the exception just before | |
| # allowing .join() to return. | |
| __exc_clear = _sys.exc_clear | |
| def __init__(self, group=None, target=None, name=None, | |
| args=(), kwargs=None, verbose=None): | |
| """This constructor should always be called with keyword arguments. Arguments are: | |
| *group* should be None; reserved for future extension when a ThreadGroup | |
| class is implemented. | |
| *target* is the callable object to be invoked by the run() | |
| method. Defaults to None, meaning nothing is called. | |
| *name* is the thread name. By default, a unique name is constructed of | |
| the form "Thread-N" where N is a small decimal number. | |
| *args* is the argument tuple for the target invocation. Defaults to (). | |
| *kwargs* is a dictionary of keyword arguments for the target | |
| invocation. Defaults to {}. | |
| If a subclass overrides the constructor, it must make sure to invoke | |
| the base class constructor (Thread.__init__()) before doing anything | |
| else to the thread. | |
| """ | |
| assert group is None, "group argument must be None for now" | |
| _Verbose.__init__(self, verbose) | |
| if kwargs is None: | |
| kwargs = {} | |
| self.__target = target | |
| self.__name = str(name or _newname()) | |
| self.__args = args | |
| self.__kwargs = kwargs | |
| self.__daemonic = self._set_daemon() | |
| self.__ident = None | |
| self.__started = Event() | |
| self.__stopped = False | |
| self.__block = Condition(Lock()) | |
| self.__initialized = True | |
| # sys.stderr is not stored in the class like | |
| # sys.exc_info since it can be changed between instances | |
| self.__stderr = _sys.stderr | |
| def _reset_internal_locks(self): | |
| # private! Called by _after_fork() to reset our internal locks as | |
| # they may be in an invalid state leading to a deadlock or crash. | |
| if hasattr(self, '_Thread__block'): # DummyThread deletes self.__block | |
| self.__block.__init__() | |
| self.__started._reset_internal_locks() | |
| @property | |
| def _block(self): | |
| # used by a unittest | |
| return self.__block | |
| def _set_daemon(self): | |
| # Overridden in _MainThread and _DummyThread | |
| return current_thread().daemon | |
| def __repr__(self): | |
| assert self.__initialized, "Thread.__init__() was not called" | |
| status = "initial" | |
| if self.__started.is_set(): | |
| status = "started" | |
| if self.__stopped: | |
| status = "stopped" | |
| if self.__daemonic: | |
| status += " daemon" | |
| if self.__ident is not None: | |
| status += " %s" % self.__ident | |
| return "<%s(%s, %s)>" % (self.__class__.__name__, self.__name, status) | |
| def start(self): | |
| """Start the thread's activity. | |
| It must be called at most once per thread object. It arranges for the | |
| object's run() method to be invoked in a separate thread of control. | |
| This method will raise a RuntimeError if called more than once on the | |
| same thread object. | |
| """ | |
| if not self.__initialized: | |
| raise RuntimeError("thread.__init__() not called") | |
| if self.__started.is_set(): | |
| raise RuntimeError("threads can only be started once") | |
| if __debug__: | |
| self._note("%s.start(): starting thread", self) | |
| with _active_limbo_lock: | |
| _limbo[self] = self | |
| try: | |
| _start_new_thread(self.__bootstrap, ()) | |
| except Exception: | |
| with _active_limbo_lock: | |
| del _limbo[self] | |
| raise | |
| self.__started.wait() | |
| def run(self): | |
| """Method representing the thread's activity. | |
| You may override this method in a subclass. The standard run() method | |
| invokes the callable object passed to the object's constructor as the | |
| target argument, if any, with sequential and keyword arguments taken | |
| from the args and kwargs arguments, respectively. | |
| """ | |
| try: | |
| if self.__target: | |
| self.__target(*self.__args, **self.__kwargs) | |
| finally: | |
| # Avoid a refcycle if the thread is running a function with | |
| # an argument that has a member that points to the thread. | |
| del self.__target, self.__args, self.__kwargs | |
| def __bootstrap(self): | |
| # Wrapper around the real bootstrap code that ignores | |
| # exceptions during interpreter cleanup. Those typically | |
| # happen when a daemon thread wakes up at an unfortunate | |
| # moment, finds the world around it destroyed, and raises some | |
| # random exception *** while trying to report the exception in | |
| # __bootstrap_inner() below ***. Those random exceptions | |
| # don't help anybody, and they confuse users, so we suppress | |
| # them. We suppress them only when it appears that the world | |
| # indeed has already been destroyed, so that exceptions in | |
| # __bootstrap_inner() during normal business hours are properly | |
| # reported. Also, we only suppress them for daemonic threads; | |
| # if a non-daemonic encounters this, something else is wrong. | |
| try: | |
| self.__bootstrap_inner() | |
| except: | |
| if self.__daemonic and _sys is None: | |
| return | |
| raise | |
| def _set_ident(self): | |
| self.__ident = _get_ident() | |
| def __bootstrap_inner(self): | |
| try: | |
| self._set_ident() | |
| self.__started.set() | |
| with _active_limbo_lock: | |
| _active[self.__ident] = self | |
| del _limbo[self] | |
| if __debug__: | |
| self._note("%s.__bootstrap(): thread started", self) | |
| if _trace_hook: | |
| self._note("%s.__bootstrap(): registering trace hook", self) | |
| _sys.settrace(_trace_hook) | |
| if _profile_hook: | |
| self._note("%s.__bootstrap(): registering profile hook", self) | |
| _sys.setprofile(_profile_hook) | |
| try: | |
| self.run() | |
| except SystemExit: | |
| if __debug__: | |
| self._note("%s.__bootstrap(): raised SystemExit", self) | |
| except: | |
| if __debug__: | |
| self._note("%s.__bootstrap(): unhandled exception", self) | |
| # If sys.stderr is no more (most likely from interpreter | |
| # shutdown) use self.__stderr. Otherwise still use sys (as in | |
| # _sys) in case sys.stderr was redefined since the creation of | |
| # self. | |
| if _sys and _sys.stderr is not None: | |
| print>>_sys.stderr, ("Exception in thread %s:\n%s" % | |
| (self.name, _format_exc())) | |
| elif self.__stderr is not None: | |
| # Do the best job possible w/o a huge amt. of code to | |
| # approximate a traceback (code ideas from | |
| # Lib/traceback.py) | |
| exc_type, exc_value, exc_tb = self.__exc_info() | |
| try: | |
| print>>self.__stderr, ( | |
| "Exception in thread " + self.name + | |
| " (most likely raised during interpreter shutdown):") | |
| print>>self.__stderr, ( | |
| "Traceback (most recent call last):") | |
| while exc_tb: | |
| print>>self.__stderr, ( | |
| ' File "%s", line %s, in %s' % | |
| (exc_tb.tb_frame.f_code.co_filename, | |
| exc_tb.tb_lineno, | |
| exc_tb.tb_frame.f_code.co_name)) | |
| exc_tb = exc_tb.tb_next | |
| print>>self.__stderr, ("%s: %s" % (exc_type, exc_value)) | |
| # Make sure that exc_tb gets deleted since it is a memory | |
| # hog; deleting everything else is just for thoroughness | |
| finally: | |
| del exc_type, exc_value, exc_tb | |
| else: | |
| if __debug__: | |
| self._note("%s.__bootstrap(): normal return", self) | |
| finally: | |
| # Prevent a race in | |
| # test_threading.test_no_refcycle_through_target when | |
| # the exception keeps the target alive past when we | |
| # assert that it's dead. | |
| self.__exc_clear() | |
| finally: | |
| with _active_limbo_lock: | |
| self.__stop() | |
| try: | |
| # We don't call self.__delete() because it also | |
| # grabs _active_limbo_lock. | |
| del _active[_get_ident()] | |
| except: | |
| pass | |
| def __stop(self): | |
| # DummyThreads delete self.__block, but they have no waiters to | |
| # notify anyway (join() is forbidden on them). | |
| if not hasattr(self, '_Thread__block'): | |
| return | |
| self.__block.acquire() | |
| self.__stopped = True | |
| self.__block.notify_all() | |
| self.__block.release() | |
| def __delete(self): | |
| "Remove current thread from the dict of currently running threads." | |
| # Notes about running with dummy_thread: | |
| # | |
| # Must take care to not raise an exception if dummy_thread is being | |
| # used (and thus this module is being used as an instance of | |
| # dummy_threading). dummy_thread.get_ident() always returns -1 since | |
| # there is only one thread if dummy_thread is being used. Thus | |
| # len(_active) is always <= 1 here, and any Thread instance created | |
| # overwrites the (if any) thread currently registered in _active. | |
| # | |
| # An instance of _MainThread is always created by 'threading'. This | |
| # gets overwritten the instant an instance of Thread is created; both | |
| # threads return -1 from dummy_thread.get_ident() and thus have the | |
| # same key in the dict. So when the _MainThread instance created by | |
| # 'threading' tries to clean itself up when atexit calls this method | |
| # it gets a KeyError if another Thread instance was created. | |
| # | |
| # This all means that KeyError from trying to delete something from | |
| # _active if dummy_threading is being used is a red herring. But | |
| # since it isn't if dummy_threading is *not* being used then don't | |
| # hide the exception. | |
| try: | |
| with _active_limbo_lock: | |
| del _active[_get_ident()] | |
| # There must not be any python code between the previous line | |
| # and after the lock is released. Otherwise a tracing function | |
| # could try to acquire the lock again in the same thread, (in | |
| # current_thread()), and would block. | |
| except KeyError: | |
| if 'dummy_threading' not in _sys.modules: | |
| raise | |
| def join(self, timeout=None): | |
| """Wait until the thread terminates. | |
| This blocks the calling thread until the thread whose join() method is | |
| called terminates -- either normally or through an unhandled exception | |
| or until the optional timeout occurs. | |
| When the timeout argument is present and not None, it should be a | |
| floating point number specifying a timeout for the operation in seconds | |
| (or fractions thereof). As join() always returns None, you must call | |
| isAlive() after join() to decide whether a timeout happened -- if the | |
| thread is still alive, the join() call timed out. | |
| When the timeout argument is not present or None, the operation will | |
| block until the thread terminates. | |
| A thread can be join()ed many times. | |
| join() raises a RuntimeError if an attempt is made to join the current | |
| thread as that would cause a deadlock. It is also an error to join() a | |
| thread before it has been started and attempts to do so raises the same | |
| exception. | |
| """ | |
| if not self.__initialized: | |
| raise RuntimeError("Thread.__init__() not called") | |
| if not self.__started.is_set(): | |
| raise RuntimeError("cannot join thread before it is started") | |
| if self is current_thread(): | |
| raise RuntimeError("cannot join current thread") | |
| if __debug__: | |
| if not self.__stopped: | |
| self._note("%s.join(): waiting until thread stops", self) | |
| self.__block.acquire() | |
| try: | |
| 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) | |
| finally: | |
| self.__block.release() | |
| @property | |
| def name(self): | |
| """A string used for identification purposes only. | |
| It has no semantics. Multiple threads may be given the same name. The | |
| initial name is set by the constructor. | |
| """ | |
| assert self.__initialized, "Thread.__init__() not called" | |
| return self.__name | |
| @name.setter | |
| def name(self, name): | |
| assert self.__initialized, "Thread.__init__() not called" | |
| self.__name = str(name) | |
| @property | |
| def ident(self): | |
| """Thread identifier of this thread or None if it has not been started. | |
| This is a nonzero integer. See the thread.get_ident() function. Thread | |
| identifiers may be recycled when a thread exits and another thread is | |
| created. The identifier is available even after the thread has exited. | |
| """ | |
| assert self.__initialized, "Thread.__init__() not called" | |
| return self.__ident | |
| def isAlive(self): | |
| """Return whether the thread is alive. | |
| This method returns True just before the run() method starts until just | |
| after the run() method terminates. The module function enumerate() | |
| returns a list of all alive threads. | |
| """ | |
| assert self.__initialized, "Thread.__init__() not called" | |
| return self.__started.is_set() and not self.__stopped | |
| is_alive = isAlive | |
| @property | |
| def daemon(self): | |
| """A boolean value indicating whether this thread is a daemon thread (True) or not (False). | |
| This must be set before start() is called, otherwise RuntimeError is | |
| raised. Its initial value is inherited from the creating thread; the | |
| main thread is not a daemon thread and therefore all threads created in | |
| the main thread default to daemon = False. | |
| The entire Python program exits when no alive non-daemon threads are | |
| left. | |
| """ | |
| assert self.__initialized, "Thread.__init__() not called" | |
| return self.__daemonic | |
| @daemon.setter | |
| def daemon(self, daemonic): | |
| if not self.__initialized: | |
| raise RuntimeError("Thread.__init__() not called") | |
| if self.__started.is_set(): | |
| raise RuntimeError("cannot set daemon status of active thread"); | |
| self.__daemonic = daemonic | |
| def isDaemon(self): | |
| return self.daemon | |
| def setDaemon(self, daemonic): | |
| self.daemon = daemonic | |
| def getName(self): | |
| return self.name | |
| def setName(self, name): | |
| self.name = name | |
| # The timer class was contributed by Itamar Shtull-Trauring | |
| def Timer(*args, **kwargs): | |
| """Factory function to create a Timer object. | |
| Timers call a function after a specified number of seconds: | |
| t = Timer(30.0, f, args=[], kwargs={}) | |
| t.start() | |
| t.cancel() # stop the timer's action if it's still waiting | |
| """ | |
| return _Timer(*args, **kwargs) | |
| class _Timer(Thread): | |
| """Call a function after a specified number of seconds: | |
| t = Timer(30.0, f, args=[], kwargs={}) | |
| t.start() | |
| t.cancel() # stop the timer's action if it's still waiting | |
| """ | |
| def __init__(self, interval, function, args=[], kwargs={}): | |
| Thread.__init__(self) | |
| self.interval = interval | |
| self.function = function | |
| self.args = args | |
| self.kwargs = kwargs | |
| self.finished = Event() | |
| def cancel(self): | |
| """Stop the timer if it hasn't finished yet""" | |
| self.finished.set() | |
| def run(self): | |
| self.finished.wait(self.interval) | |
| if not self.finished.is_set(): | |
| self.function(*self.args, **self.kwargs) | |
| self.finished.set() | |
| # 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.set() | |
| self._set_ident() | |
| with _active_limbo_lock: | |
| _active[_get_ident()] = self | |
| def _set_daemon(self): | |
| return False | |
| 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 __debug__: | |
| self._note("%s: exiting", self) | |
| self._Thread__delete() | |
| def _pickSomeNonDaemonThread(): | |
| for t in enumerate(): | |
| if not t.daemon and t.is_alive(): | |
| 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. | |
| # If they invoke anything in threading.py that calls current_thread(), they | |
| # leave an entry in the _active dict forever after. | |
| # Their purpose is to return *something* from current_thread(). | |
| # 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")) | |
| # Thread.__block consumes an OS-level locking primitive, which | |
| # can never be used by a _DummyThread. Since a _DummyThread | |
| # instance is immortal, that's bad, so release this resource. | |
| del self._Thread__block | |
| self._Thread__started.set() | |
| self._set_ident() | |
| with _active_limbo_lock: | |
| _active[_get_ident()] = self | |
| def _set_daemon(self): | |
| return True | |
| def join(self, timeout=None): | |
| assert False, "cannot join a dummy thread" | |
| # Global API functions | |
| def currentThread(): | |
| """Return the current Thread object, corresponding to the caller's thread of control. | |
| If the caller's thread of control was not created through the threading | |
| module, a dummy thread object with limited functionality is returned. | |
| """ | |
| try: | |
| return _active[_get_ident()] | |
| except KeyError: | |
| ##print "current_thread(): no current thread for", _get_ident() | |
| return _DummyThread() | |
| current_thread = currentThread | |
| def activeCount(): | |
| """Return the number of Thread objects currently alive. | |
| The returned count is equal to the length of the list returned by | |
| enumerate(). | |
| """ | |
| with _active_limbo_lock: | |
| return len(_active) + len(_limbo) | |
| active_count = activeCount | |
| def _enumerate(): | |
| # Same as enumerate(), but without the lock. Internal use only. | |
| return _active.values() + _limbo.values() | |
| def enumerate(): | |
| """Return a list of all Thread objects currently alive. | |
| The list includes daemonic threads, dummy thread objects created by | |
| current_thread(), and the main thread. It excludes terminated threads and | |
| threads that have not yet been started. | |
| """ | |
| with _active_limbo_lock: | |
| return _active.values() + _limbo.values() | |
| from thread import stack_size | |
| # Create the main thread object, | |
| # and make it available for the interpreter | |
| # (Py_Main) as threading._shutdown. | |
| _shutdown = _MainThread()._exitfunc | |
| # get thread-local implementation, either from the thread | |
| # module, or from the python fallback | |
| try: | |
| from thread import _local as local | |
| except ImportError: | |
| from _threading_local import local | |
| def _after_fork(): | |
| # This function is called by Python/ceval.c:PyEval_ReInitThreads which | |
| # is called from PyOS_AfterFork. Here we cleanup threading module state | |
| # that should not exist after a fork. | |
| # Reset _active_limbo_lock, in case we forked while the lock was held | |
| # by another (non-forked) thread. http://bugs.python.org/issue874900 | |
| global _active_limbo_lock | |
| _active_limbo_lock = _allocate_lock() | |
| # fork() only copied the current thread; clear references to others. | |
| new_active = {} | |
| current = current_thread() | |
| with _active_limbo_lock: | |
| for thread in _enumerate(): | |
| # Any lock/condition variable may be currently locked or in an | |
| # invalid state, so we reinitialize them. | |
| if hasattr(thread, '_reset_internal_locks'): | |
| thread._reset_internal_locks() | |
| if thread is current: | |
| # There is only one active thread. We reset the ident to | |
| # its new value since it can have changed. | |
| ident = _get_ident() | |
| thread._Thread__ident = ident | |
| new_active[ident] = thread | |
| else: | |
| # All the others are already stopped. | |
| thread._Thread__stop() | |
| _limbo.clear() | |
| _active.clear() | |
| _active.update(new_active) | |
| assert len(_active) == 1 | |
| # Self-test code | |
| def _test(): | |
| 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 = _deque() | |
| 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.popleft() | |
| 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.name, 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 | |
| NP = 3 | |
| QL = 4 | |
| NI = 5 | |
| Q = BoundedQueue(QL) | |
| P = [] | |
| for i in range(NP): | |
| t = ProducerThread(Q, NI) | |
| t.name = ("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() |