home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Inkscape / Inkscape-0.48.2-1-win32.exe / python / Lib / threading.py < prev    next >
Encoding:
Python Source  |  2010-05-29  |  32.0 KB  |  972 lines
  1. """Thread module emulating a subset of Java's threading model."""
  2.  
  3. import sys as _sys
  4.  
  5. try:
  6.     import thread
  7. except ImportError:
  8.     del _sys.modules[__name__]
  9.     raise
  10.  
  11. import warnings
  12.  
  13. from functools import wraps
  14. from time import time as _time, sleep as _sleep
  15. from traceback import format_exc as _format_exc
  16. from collections import deque
  17.  
  18. # Note regarding PEP 8 compliant aliases
  19. #  This threading model was originally inspired by Java, and inherited
  20. # the convention of camelCase function and method names from that
  21. # language. While those names are not in any imminent danger of being
  22. # deprecated, starting with Python 2.6, the module now provides a
  23. # PEP 8 compliant alias for any such method name.
  24. # Using the new PEP 8 compliant names also facilitates substitution
  25. # with the multiprocessing module, which doesn't provide the old
  26. # Java inspired names.
  27.  
  28.  
  29. # Rename some stuff so "from threading import *" is safe
  30. __all__ = ['activeCount', 'active_count', 'Condition', 'currentThread',
  31.            'current_thread', 'enumerate', 'Event',
  32.            'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread',
  33.            'Timer', 'setprofile', 'settrace', 'local', 'stack_size']
  34.  
  35. _start_new_thread = thread.start_new_thread
  36. _allocate_lock = thread.allocate_lock
  37. _get_ident = thread.get_ident
  38. ThreadError = thread.error
  39. del thread
  40.  
  41.  
  42. # sys.exc_clear is used to work around the fact that except blocks
  43. # don't fully clear the exception until 3.0.
  44. warnings.filterwarnings('ignore', category=DeprecationWarning,
  45.                         module='threading', message='sys.exc_clear')
  46.  
  47. # Debug support (adapted from ihooks.py).
  48. # All the major classes here derive from _Verbose.  We force that to
  49. # be a new-style class so that all the major classes here are new-style.
  50. # This helps debugging (type(instance) is more revealing for instances
  51. # of new-style classes).
  52.  
  53. _VERBOSE = False
  54.  
  55. if __debug__:
  56.  
  57.     class _Verbose(object):
  58.  
  59.         def __init__(self, verbose=None):
  60.             if verbose is None:
  61.                 verbose = _VERBOSE
  62.             self.__verbose = verbose
  63.  
  64.         def _note(self, format, *args):
  65.             if self.__verbose:
  66.                 format = format % args
  67.                 format = "%s: %s\n" % (
  68.                     current_thread().name, format)
  69.                 _sys.stderr.write(format)
  70.  
  71. else:
  72.     # Disable this when using "python -O"
  73.     class _Verbose(object):
  74.         def __init__(self, verbose=None):
  75.             pass
  76.         def _note(self, *args):
  77.             pass
  78.  
  79. # Support for profile and trace hooks
  80.  
  81. _profile_hook = None
  82. _trace_hook = None
  83.  
  84. def setprofile(func):
  85.     global _profile_hook
  86.     _profile_hook = func
  87.  
  88. def settrace(func):
  89.     global _trace_hook
  90.     _trace_hook = func
  91.  
  92. # Synchronization classes
  93.  
  94. Lock = _allocate_lock
  95.  
  96. def RLock(*args, **kwargs):
  97.     return _RLock(*args, **kwargs)
  98.  
  99. class _RLock(_Verbose):
  100.  
  101.     def __init__(self, verbose=None):
  102.         _Verbose.__init__(self, verbose)
  103.         self.__block = _allocate_lock()
  104.         self.__owner = None
  105.         self.__count = 0
  106.  
  107.     def __repr__(self):
  108.         owner = self.__owner
  109.         try:
  110.             owner = _active[owner].name
  111.         except KeyError:
  112.             pass
  113.         return "<%s owner=%r count=%d>" % (
  114.                 self.__class__.__name__, owner, self.__count)
  115.  
  116.     def acquire(self, blocking=1):
  117.         me = _get_ident()
  118.         if self.__owner == me:
  119.             self.__count = self.__count + 1
  120.             if __debug__:
  121.                 self._note("%s.acquire(%s): recursive success", self, blocking)
  122.             return 1
  123.         rc = self.__block.acquire(blocking)
  124.         if rc:
  125.             self.__owner = me
  126.             self.__count = 1
  127.             if __debug__:
  128.                 self._note("%s.acquire(%s): initial success", self, blocking)
  129.         else:
  130.             if __debug__:
  131.                 self._note("%s.acquire(%s): failure", self, blocking)
  132.         return rc
  133.  
  134.     __enter__ = acquire
  135.  
  136.     def release(self):
  137.         if self.__owner != _get_ident():
  138.             raise RuntimeError("cannot release un-acquired lock")
  139.         self.__count = count = self.__count - 1
  140.         if not count:
  141.             self.__owner = None
  142.             self.__block.release()
  143.             if __debug__:
  144.                 self._note("%s.release(): final release", self)
  145.         else:
  146.             if __debug__:
  147.                 self._note("%s.release(): non-final release", self)
  148.  
  149.     def __exit__(self, t, v, tb):
  150.         self.release()
  151.  
  152.     # Internal methods used by condition variables
  153.  
  154.     def _acquire_restore(self, count_owner):
  155.         count, owner = count_owner
  156.         self.__block.acquire()
  157.         self.__count = count
  158.         self.__owner = owner
  159.         if __debug__:
  160.             self._note("%s._acquire_restore()", self)
  161.  
  162.     def _release_save(self):
  163.         if __debug__:
  164.             self._note("%s._release_save()", self)
  165.         count = self.__count
  166.         self.__count = 0
  167.         owner = self.__owner
  168.         self.__owner = None
  169.         self.__block.release()
  170.         return (count, owner)
  171.  
  172.     def _is_owned(self):
  173.         return self.__owner == _get_ident()
  174.  
  175.  
  176. def Condition(*args, **kwargs):
  177.     return _Condition(*args, **kwargs)
  178.  
  179. class _Condition(_Verbose):
  180.  
  181.     def __init__(self, lock=None, verbose=None):
  182.         _Verbose.__init__(self, verbose)
  183.         if lock is None:
  184.             lock = RLock()
  185.         self.__lock = lock
  186.         # Export the lock's acquire() and release() methods
  187.         self.acquire = lock.acquire
  188.         self.release = lock.release
  189.         # If the lock defines _release_save() and/or _acquire_restore(),
  190.         # these override the default implementations (which just call
  191.         # release() and acquire() on the lock).  Ditto for _is_owned().
  192.         try:
  193.             self._release_save = lock._release_save
  194.         except AttributeError:
  195.             pass
  196.         try:
  197.             self._acquire_restore = lock._acquire_restore
  198.         except AttributeError:
  199.             pass
  200.         try:
  201.             self._is_owned = lock._is_owned
  202.         except AttributeError:
  203.             pass
  204.         self.__waiters = []
  205.  
  206.     def __enter__(self):
  207.         return self.__lock.__enter__()
  208.  
  209.     def __exit__(self, *args):
  210.         return self.__lock.__exit__(*args)
  211.  
  212.     def __repr__(self):
  213.         return "<Condition(%s, %d)>" % (self.__lock, len(self.__waiters))
  214.  
  215.     def _release_save(self):
  216.         self.__lock.release()           # No state to save
  217.  
  218.     def _acquire_restore(self, x):
  219.         self.__lock.acquire()           # Ignore saved state
  220.  
  221.     def _is_owned(self):
  222.         # Return True if lock is owned by current_thread.
  223.         # This method is called only if __lock doesn't have _is_owned().
  224.         if self.__lock.acquire(0):
  225.             self.__lock.release()
  226.             return False
  227.         else:
  228.             return True
  229.  
  230.     def wait(self, timeout=None):
  231.         if not self._is_owned():
  232.             raise RuntimeError("cannot wait on un-acquired lock")
  233.         waiter = _allocate_lock()
  234.         waiter.acquire()
  235.         self.__waiters.append(waiter)
  236.         saved_state = self._release_save()
  237.         try:    # restore state no matter what (e.g., KeyboardInterrupt)
  238.             if timeout is None:
  239.                 waiter.acquire()
  240.                 if __debug__:
  241.                     self._note("%s.wait(): got it", self)
  242.             else:
  243.                 # Balancing act:  We can't afford a pure busy loop, so we
  244.                 # have to sleep; but if we sleep the whole timeout time,
  245.                 # we'll be unresponsive.  The scheme here sleeps very
  246.                 # little at first, longer as time goes on, but never longer
  247.                 # than 20 times per second (or the timeout time remaining).
  248.                 endtime = _time() + timeout
  249.                 delay = 0.0005 # 500 us -> initial delay of 1 ms
  250.                 while True:
  251.                     gotit = waiter.acquire(0)
  252.                     if gotit:
  253.                         break
  254.                     remaining = endtime - _time()
  255.                     if remaining <= 0:
  256.                         break
  257.                     delay = min(delay * 2, remaining, .05)
  258.                     _sleep(delay)
  259.                 if not gotit:
  260.                     if __debug__:
  261.                         self._note("%s.wait(%s): timed out", self, timeout)
  262.                     try:
  263.                         self.__waiters.remove(waiter)
  264.                     except ValueError:
  265.                         pass
  266.                 else:
  267.                     if __debug__:
  268.                         self._note("%s.wait(%s): got it", self, timeout)
  269.         finally:
  270.             self._acquire_restore(saved_state)
  271.  
  272.     def notify(self, n=1):
  273.         if not self._is_owned():
  274.             raise RuntimeError("cannot notify on un-acquired lock")
  275.         __waiters = self.__waiters
  276.         waiters = __waiters[:n]
  277.         if not waiters:
  278.             if __debug__:
  279.                 self._note("%s.notify(): no waiters", self)
  280.             return
  281.         self._note("%s.notify(): notifying %d waiter%s", self, n,
  282.                    n!=1 and "s" or "")
  283.         for waiter in waiters:
  284.             waiter.release()
  285.             try:
  286.                 __waiters.remove(waiter)
  287.             except ValueError:
  288.                 pass
  289.  
  290.     def notifyAll(self):
  291.         self.notify(len(self.__waiters))
  292.  
  293.     notify_all = notifyAll
  294.  
  295.  
  296. def Semaphore(*args, **kwargs):
  297.     return _Semaphore(*args, **kwargs)
  298.  
  299. class _Semaphore(_Verbose):
  300.  
  301.     # After Tim Peters' semaphore class, but not quite the same (no maximum)
  302.  
  303.     def __init__(self, value=1, verbose=None):
  304.         if value < 0:
  305.             raise ValueError("semaphore initial value must be >= 0")
  306.         _Verbose.__init__(self, verbose)
  307.         self.__cond = Condition(Lock())
  308.         self.__value = value
  309.  
  310.     def acquire(self, blocking=1):
  311.         rc = False
  312.         self.__cond.acquire()
  313.         while self.__value == 0:
  314.             if not blocking:
  315.                 break
  316.             if __debug__:
  317.                 self._note("%s.acquire(%s): blocked waiting, value=%s",
  318.                            self, blocking, self.__value)
  319.             self.__cond.wait()
  320.         else:
  321.             self.__value = self.__value - 1
  322.             if __debug__:
  323.                 self._note("%s.acquire: success, value=%s",
  324.                            self, self.__value)
  325.             rc = True
  326.         self.__cond.release()
  327.         return rc
  328.  
  329.     __enter__ = acquire
  330.  
  331.     def release(self):
  332.         self.__cond.acquire()
  333.         self.__value = self.__value + 1
  334.         if __debug__:
  335.             self._note("%s.release: success, value=%s",
  336.                        self, self.__value)
  337.         self.__cond.notify()
  338.         self.__cond.release()
  339.  
  340.     def __exit__(self, t, v, tb):
  341.         self.release()
  342.  
  343.  
  344. def BoundedSemaphore(*args, **kwargs):
  345.     return _BoundedSemaphore(*args, **kwargs)
  346.  
  347. class _BoundedSemaphore(_Semaphore):
  348.     """Semaphore that checks that # releases is <= # acquires"""
  349.     def __init__(self, value=1, verbose=None):
  350.         _Semaphore.__init__(self, value, verbose)
  351.         self._initial_value = value
  352.  
  353.     def release(self):
  354.         if self._Semaphore__value >= self._initial_value:
  355.             raise ValueError, "Semaphore released too many times"
  356.         return _Semaphore.release(self)
  357.  
  358.  
  359. def Event(*args, **kwargs):
  360.     return _Event(*args, **kwargs)
  361.  
  362. class _Event(_Verbose):
  363.  
  364.     # After Tim Peters' event class (without is_posted())
  365.  
  366.     def __init__(self, verbose=None):
  367.         _Verbose.__init__(self, verbose)
  368.         self.__cond = Condition(Lock())
  369.         self.__flag = False
  370.  
  371.     def isSet(self):
  372.         return self.__flag
  373.  
  374.     is_set = isSet
  375.  
  376.     def set(self):
  377.         self.__cond.acquire()
  378.         try:
  379.             self.__flag = True
  380.             self.__cond.notify_all()
  381.         finally:
  382.             self.__cond.release()
  383.  
  384.     def clear(self):
  385.         self.__cond.acquire()
  386.         try:
  387.             self.__flag = False
  388.         finally:
  389.             self.__cond.release()
  390.  
  391.     def wait(self, timeout=None):
  392.         self.__cond.acquire()
  393.         try:
  394.             if not self.__flag:
  395.                 self.__cond.wait(timeout)
  396.         finally:
  397.             self.__cond.release()
  398.  
  399. # Helper to generate new thread names
  400. _counter = 0
  401. def _newname(template="Thread-%d"):
  402.     global _counter
  403.     _counter = _counter + 1
  404.     return template % _counter
  405.  
  406. # Active thread administration
  407. _active_limbo_lock = _allocate_lock()
  408. _active = {}    # maps thread id to Thread object
  409. _limbo = {}
  410.  
  411.  
  412. # Main class for threads
  413.  
  414. class Thread(_Verbose):
  415.  
  416.     __initialized = False
  417.     # Need to store a reference to sys.exc_info for printing
  418.     # out exceptions when a thread tries to use a global var. during interp.
  419.     # shutdown and thus raises an exception about trying to perform some
  420.     # operation on/with a NoneType
  421.     __exc_info = _sys.exc_info
  422.     # Keep sys.exc_clear too to clear the exception just before
  423.     # allowing .join() to return.
  424.     __exc_clear = _sys.exc_clear
  425.  
  426.     def __init__(self, group=None, target=None, name=None,
  427.                  args=(), kwargs=None, verbose=None):
  428.         assert group is None, "group argument must be None for now"
  429.         _Verbose.__init__(self, verbose)
  430.         if kwargs is None:
  431.             kwargs = {}
  432.         self.__target = target
  433.         self.__name = str(name or _newname())
  434.         self.__args = args
  435.         self.__kwargs = kwargs
  436.         self.__daemonic = self._set_daemon()
  437.         self.__ident = None
  438.         self.__started = Event()
  439.         self.__stopped = False
  440.         self.__block = Condition(Lock())
  441.         self.__initialized = True
  442.         # sys.stderr is not stored in the class like
  443.         # sys.exc_info since it can be changed between instances
  444.         self.__stderr = _sys.stderr
  445.  
  446.     def _set_daemon(self):
  447.         # Overridden in _MainThread and _DummyThread
  448.         return current_thread().daemon
  449.  
  450.     def __repr__(self):
  451.         assert self.__initialized, "Thread.__init__() was not called"
  452.         status = "initial"
  453.         if self.__started.is_set():
  454.             status = "started"
  455.         if self.__stopped:
  456.             status = "stopped"
  457.         if self.__daemonic:
  458.             status += " daemon"
  459.         if self.__ident is not None:
  460.             status += " %s" % self.__ident
  461.         return "<%s(%s, %s)>" % (self.__class__.__name__, self.__name, status)
  462.  
  463.     def start(self):
  464.         if not self.__initialized:
  465.             raise RuntimeError("thread.__init__() not called")
  466.         if self.__started.is_set():
  467.             raise RuntimeError("thread already started")
  468.         if __debug__:
  469.             self._note("%s.start(): starting thread", self)
  470.         _active_limbo_lock.acquire()
  471.         _limbo[self] = self
  472.         _active_limbo_lock.release()
  473.         try:
  474.             _start_new_thread(self.__bootstrap, ())
  475.         except Exception:
  476.             with _active_limbo_lock:
  477.                 del _limbo[self]
  478.             raise
  479.         self.__started.wait()
  480.  
  481.     def run(self):
  482.         try:
  483.             if self.__target:
  484.                 self.__target(*self.__args, **self.__kwargs)
  485.         finally:
  486.             # Avoid a refcycle if the thread is running a function with
  487.             # an argument that has a member that points to the thread.
  488.             del self.__target, self.__args, self.__kwargs
  489.  
  490.     def __bootstrap(self):
  491.         # Wrapper around the real bootstrap code that ignores
  492.         # exceptions during interpreter cleanup.  Those typically
  493.         # happen when a daemon thread wakes up at an unfortunate
  494.         # moment, finds the world around it destroyed, and raises some
  495.         # random exception *** while trying to report the exception in
  496.         # __bootstrap_inner() below ***.  Those random exceptions
  497.         # don't help anybody, and they confuse users, so we suppress
  498.         # them.  We suppress them only when it appears that the world
  499.         # indeed has already been destroyed, so that exceptions in
  500.         # __bootstrap_inner() during normal business hours are properly
  501.         # reported.  Also, we only suppress them for daemonic threads;
  502.         # if a non-daemonic encounters this, something else is wrong.
  503.         try:
  504.             self.__bootstrap_inner()
  505.         except:
  506.             if self.__daemonic and _sys is None:
  507.                 return
  508.             raise
  509.  
  510.     def _set_ident(self):
  511.         self.__ident = _get_ident()
  512.  
  513.     def __bootstrap_inner(self):
  514.         try:
  515.             self._set_ident()
  516.             self.__started.set()
  517.             _active_limbo_lock.acquire()
  518.             _active[self.__ident] = self
  519.             del _limbo[self]
  520.             _active_limbo_lock.release()
  521.             if __debug__:
  522.                 self._note("%s.__bootstrap(): thread started", self)
  523.  
  524.             if _trace_hook:
  525.                 self._note("%s.__bootstrap(): registering trace hook", self)
  526.                 _sys.settrace(_trace_hook)
  527.             if _profile_hook:
  528.                 self._note("%s.__bootstrap(): registering profile hook", self)
  529.                 _sys.setprofile(_profile_hook)
  530.  
  531.             try:
  532.                 self.run()
  533.             except SystemExit:
  534.                 if __debug__:
  535.                     self._note("%s.__bootstrap(): raised SystemExit", self)
  536.             except:
  537.                 if __debug__:
  538.                     self._note("%s.__bootstrap(): unhandled exception", self)
  539.                 # If sys.stderr is no more (most likely from interpreter
  540.                 # shutdown) use self.__stderr.  Otherwise still use sys (as in
  541.                 # _sys) in case sys.stderr was redefined since the creation of
  542.                 # self.
  543.                 if _sys:
  544.                     _sys.stderr.write("Exception in thread %s:\n%s\n" %
  545.                                       (self.name, _format_exc()))
  546.                 else:
  547.                     # Do the best job possible w/o a huge amt. of code to
  548.                     # approximate a traceback (code ideas from
  549.                     # Lib/traceback.py)
  550.                     exc_type, exc_value, exc_tb = self.__exc_info()
  551.                     try:
  552.                         print>>self.__stderr, (
  553.                             "Exception in thread " + self.name +
  554.                             " (most likely raised during interpreter shutdown):")
  555.                         print>>self.__stderr, (
  556.                             "Traceback (most recent call last):")
  557.                         while exc_tb:
  558.                             print>>self.__stderr, (
  559.                                 '  File "%s", line %s, in %s' %
  560.                                 (exc_tb.tb_frame.f_code.co_filename,
  561.                                     exc_tb.tb_lineno,
  562.                                     exc_tb.tb_frame.f_code.co_name))
  563.                             exc_tb = exc_tb.tb_next
  564.                         print>>self.__stderr, ("%s: %s" % (exc_type, exc_value))
  565.                     # Make sure that exc_tb gets deleted since it is a memory
  566.                     # hog; deleting everything else is just for thoroughness
  567.                     finally:
  568.                         del exc_type, exc_value, exc_tb
  569.             else:
  570.                 if __debug__:
  571.                     self._note("%s.__bootstrap(): normal return", self)
  572.             finally:
  573.                 # Prevent a race in
  574.                 # test_threading.test_no_refcycle_through_target when
  575.                 # the exception keeps the target alive past when we
  576.                 # assert that it's dead.
  577.                 self.__exc_clear()
  578.         finally:
  579.             with _active_limbo_lock:
  580.                 self.__stop()
  581.                 try:
  582.                     # We don't call self.__delete() because it also
  583.                     # grabs _active_limbo_lock.
  584.                     del _active[_get_ident()]
  585.                 except:
  586.                     pass
  587.  
  588.     def __stop(self):
  589.         self.__block.acquire()
  590.         self.__stopped = True
  591.         self.__block.notify_all()
  592.         self.__block.release()
  593.  
  594.     def __delete(self):
  595.         "Remove current thread from the dict of currently running threads."
  596.  
  597.         # Notes about running with dummy_thread:
  598.         #
  599.         # Must take care to not raise an exception if dummy_thread is being
  600.         # used (and thus this module is being used as an instance of
  601.         # dummy_threading).  dummy_thread.get_ident() always returns -1 since
  602.         # there is only one thread if dummy_thread is being used.  Thus
  603.         # len(_active) is always <= 1 here, and any Thread instance created
  604.         # overwrites the (if any) thread currently registered in _active.
  605.         #
  606.         # An instance of _MainThread is always created by 'threading'.  This
  607.         # gets overwritten the instant an instance of Thread is created; both
  608.         # threads return -1 from dummy_thread.get_ident() and thus have the
  609.         # same key in the dict.  So when the _MainThread instance created by
  610.         # 'threading' tries to clean itself up when atexit calls this method
  611.         # it gets a KeyError if another Thread instance was created.
  612.         #
  613.         # This all means that KeyError from trying to delete something from
  614.         # _active if dummy_threading is being used is a red herring.  But
  615.         # since it isn't if dummy_threading is *not* being used then don't
  616.         # hide the exception.
  617.  
  618.         try:
  619.             with _active_limbo_lock:
  620.                 del _active[_get_ident()]
  621.                 # There must not be any python code between the previous line
  622.                 # and after the lock is released.  Otherwise a tracing function
  623.                 # could try to acquire the lock again in the same thread, (in
  624.                 # current_thread()), and would block.
  625.         except KeyError:
  626.             if 'dummy_threading' not in _sys.modules:
  627.                 raise
  628.  
  629.     def join(self, timeout=None):
  630.         if not self.__initialized:
  631.             raise RuntimeError("Thread.__init__() not called")
  632.         if not self.__started.is_set():
  633.             raise RuntimeError("cannot join thread before it is started")
  634.         if self is current_thread():
  635.             raise RuntimeError("cannot join current thread")
  636.  
  637.         if __debug__:
  638.             if not self.__stopped:
  639.                 self._note("%s.join(): waiting until thread stops", self)
  640.         self.__block.acquire()
  641.         try:
  642.             if timeout is None:
  643.                 while not self.__stopped:
  644.                     self.__block.wait()
  645.                 if __debug__:
  646.                     self._note("%s.join(): thread stopped", self)
  647.             else:
  648.                 deadline = _time() + timeout
  649.                 while not self.__stopped:
  650.                     delay = deadline - _time()
  651.                     if delay <= 0:
  652.                         if __debug__:
  653.                             self._note("%s.join(): timed out", self)
  654.                         break
  655.                     self.__block.wait(delay)
  656.                 else:
  657.                     if __debug__:
  658.                         self._note("%s.join(): thread stopped", self)
  659.         finally:
  660.             self.__block.release()
  661.  
  662.     @property
  663.     def name(self):
  664.         assert self.__initialized, "Thread.__init__() not called"
  665.         return self.__name
  666.  
  667.     @name.setter
  668.     def name(self, name):
  669.         assert self.__initialized, "Thread.__init__() not called"
  670.         self.__name = str(name)
  671.  
  672.     @property
  673.     def ident(self):
  674.         assert self.__initialized, "Thread.__init__() not called"
  675.         return self.__ident
  676.  
  677.     def isAlive(self):
  678.         assert self.__initialized, "Thread.__init__() not called"
  679.         return self.__started.is_set() and not self.__stopped
  680.  
  681.     is_alive = isAlive
  682.  
  683.     @property
  684.     def daemon(self):
  685.         assert self.__initialized, "Thread.__init__() not called"
  686.         return self.__daemonic
  687.  
  688.     @daemon.setter
  689.     def daemon(self, daemonic):
  690.         if not self.__initialized:
  691.             raise RuntimeError("Thread.__init__() not called")
  692.         if self.__started.is_set():
  693.             raise RuntimeError("cannot set daemon status of active thread");
  694.         self.__daemonic = daemonic
  695.  
  696.     def isDaemon(self):
  697.         return self.daemon
  698.  
  699.     def setDaemon(self, daemonic):
  700.         self.daemon = daemonic
  701.  
  702.     def getName(self):
  703.         return self.name
  704.  
  705.     def setName(self, name):
  706.         self.name = name
  707.  
  708. # The timer class was contributed by Itamar Shtull-Trauring
  709.  
  710. def Timer(*args, **kwargs):
  711.     return _Timer(*args, **kwargs)
  712.  
  713. class _Timer(Thread):
  714.     """Call a function after a specified number of seconds:
  715.  
  716.     t = Timer(30.0, f, args=[], kwargs={})
  717.     t.start()
  718.     t.cancel() # stop the timer's action if it's still waiting
  719.     """
  720.  
  721.     def __init__(self, interval, function, args=[], kwargs={}):
  722.         Thread.__init__(self)
  723.         self.interval = interval
  724.         self.function = function
  725.         self.args = args
  726.         self.kwargs = kwargs
  727.         self.finished = Event()
  728.  
  729.     def cancel(self):
  730.         """Stop the timer if it hasn't finished yet"""
  731.         self.finished.set()
  732.  
  733.     def run(self):
  734.         self.finished.wait(self.interval)
  735.         if not self.finished.is_set():
  736.             self.function(*self.args, **self.kwargs)
  737.         self.finished.set()
  738.  
  739. # Special thread class to represent the main thread
  740. # This is garbage collected through an exit handler
  741.  
  742. class _MainThread(Thread):
  743.  
  744.     def __init__(self):
  745.         Thread.__init__(self, name="MainThread")
  746.         self._Thread__started.set()
  747.         self._set_ident()
  748.         _active_limbo_lock.acquire()
  749.         _active[_get_ident()] = self
  750.         _active_limbo_lock.release()
  751.  
  752.     def _set_daemon(self):
  753.         return False
  754.  
  755.     def _exitfunc(self):
  756.         self._Thread__stop()
  757.         t = _pickSomeNonDaemonThread()
  758.         if t:
  759.             if __debug__:
  760.                 self._note("%s: waiting for other threads", self)
  761.         while t:
  762.             t.join()
  763.             t = _pickSomeNonDaemonThread()
  764.         if __debug__:
  765.             self._note("%s: exiting", self)
  766.         self._Thread__delete()
  767.  
  768. def _pickSomeNonDaemonThread():
  769.     for t in enumerate():
  770.         if not t.daemon and t.is_alive():
  771.             return t
  772.     return None
  773.  
  774.  
  775. # Dummy thread class to represent threads not started here.
  776. # These aren't garbage collected when they die, nor can they be waited for.
  777. # If they invoke anything in threading.py that calls current_thread(), they
  778. # leave an entry in the _active dict forever after.
  779. # Their purpose is to return *something* from current_thread().
  780. # They are marked as daemon threads so we won't wait for them
  781. # when we exit (conform previous semantics).
  782.  
  783. class _DummyThread(Thread):
  784.  
  785.     def __init__(self):
  786.         Thread.__init__(self, name=_newname("Dummy-%d"))
  787.  
  788.         # Thread.__block consumes an OS-level locking primitive, which
  789.         # can never be used by a _DummyThread.  Since a _DummyThread
  790.         # instance is immortal, that's bad, so release this resource.
  791.         del self._Thread__block
  792.  
  793.         self._Thread__started.set()
  794.         self._set_ident()
  795.         _active_limbo_lock.acquire()
  796.         _active[_get_ident()] = self
  797.         _active_limbo_lock.release()
  798.  
  799.     def _set_daemon(self):
  800.         return True
  801.  
  802.     def join(self, timeout=None):
  803.         assert False, "cannot join a dummy thread"
  804.  
  805.  
  806. # Global API functions
  807.  
  808. def currentThread():
  809.     try:
  810.         return _active[_get_ident()]
  811.     except KeyError:
  812.         ##print "current_thread(): no current thread for", _get_ident()
  813.         return _DummyThread()
  814.  
  815. current_thread = currentThread
  816.  
  817. def activeCount():
  818.     _active_limbo_lock.acquire()
  819.     count = len(_active) + len(_limbo)
  820.     _active_limbo_lock.release()
  821.     return count
  822.  
  823. active_count = activeCount
  824.  
  825. def _enumerate():
  826.     # Same as enumerate(), but without the lock. Internal use only.
  827.     return _active.values() + _limbo.values()
  828.  
  829. def enumerate():
  830.     _active_limbo_lock.acquire()
  831.     active = _active.values() + _limbo.values()
  832.     _active_limbo_lock.release()
  833.     return active
  834.  
  835. from thread import stack_size
  836.  
  837. # Create the main thread object,
  838. # and make it available for the interpreter
  839. # (Py_Main) as threading._shutdown.
  840.  
  841. _shutdown = _MainThread()._exitfunc
  842.  
  843. # get thread-local implementation, either from the thread
  844. # module, or from the python fallback
  845.  
  846. try:
  847.     from thread import _local as local
  848. except ImportError:
  849.     from _threading_local import local
  850.  
  851.  
  852. def _after_fork():
  853.     # This function is called by Python/ceval.c:PyEval_ReInitThreads which
  854.     # is called from PyOS_AfterFork.  Here we cleanup threading module state
  855.     # that should not exist after a fork.
  856.  
  857.     # Reset _active_limbo_lock, in case we forked while the lock was held
  858.     # by another (non-forked) thread.  http://bugs.python.org/issue874900
  859.     global _active_limbo_lock
  860.     _active_limbo_lock = _allocate_lock()
  861.  
  862.     # fork() only copied the current thread; clear references to others.
  863.     new_active = {}
  864.     current = current_thread()
  865.     with _active_limbo_lock:
  866.         for thread in _active.itervalues():
  867.             if thread is current:
  868.                 # There is only one active thread. We reset the ident to
  869.                 # its new value since it can have changed.
  870.                 ident = _get_ident()
  871.                 thread._Thread__ident = ident
  872.                 new_active[ident] = thread
  873.             else:
  874.                 # All the others are already stopped.
  875.                 # We don't call _Thread__stop() because it tries to acquire
  876.                 # thread._Thread__block which could also have been held while
  877.                 # we forked.
  878.                 thread._Thread__stopped = True
  879.  
  880.         _limbo.clear()
  881.         _active.clear()
  882.         _active.update(new_active)
  883.         assert len(_active) == 1
  884.  
  885.  
  886. # Self-test code
  887.  
  888. def _test():
  889.  
  890.     class BoundedQueue(_Verbose):
  891.  
  892.         def __init__(self, limit):
  893.             _Verbose.__init__(self)
  894.             self.mon = RLock()
  895.             self.rc = Condition(self.mon)
  896.             self.wc = Condition(self.mon)
  897.             self.limit = limit
  898.             self.queue = deque()
  899.  
  900.         def put(self, item):
  901.             self.mon.acquire()
  902.             while len(self.queue) >= self.limit:
  903.                 self._note("put(%s): queue full", item)
  904.                 self.wc.wait()
  905.             self.queue.append(item)
  906.             self._note("put(%s): appended, length now %d",
  907.                        item, len(self.queue))
  908.             self.rc.notify()
  909.             self.mon.release()
  910.  
  911.         def get(self):
  912.             self.mon.acquire()
  913.             while not self.queue:
  914.                 self._note("get(): queue empty")
  915.                 self.rc.wait()
  916.             item = self.queue.popleft()
  917.             self._note("get(): got %s, %d left", item, len(self.queue))
  918.             self.wc.notify()
  919.             self.mon.release()
  920.             return item
  921.  
  922.     class ProducerThread(Thread):
  923.  
  924.         def __init__(self, queue, quota):
  925.             Thread.__init__(self, name="Producer")
  926.             self.queue = queue
  927.             self.quota = quota
  928.  
  929.         def run(self):
  930.             from random import random
  931.             counter = 0
  932.             while counter < self.quota:
  933.                 counter = counter + 1
  934.                 self.queue.put("%s.%d" % (self.name, counter))
  935.                 _sleep(random() * 0.00001)
  936.  
  937.  
  938.     class ConsumerThread(Thread):
  939.  
  940.         def __init__(self, queue, count):
  941.             Thread.__init__(self, name="Consumer")
  942.             self.queue = queue
  943.             self.count = count
  944.  
  945.         def run(self):
  946.             while self.count > 0:
  947.                 item = self.queue.get()
  948.                 print item
  949.                 self.count = self.count - 1
  950.  
  951.     NP = 3
  952.     QL = 4
  953.     NI = 5
  954.  
  955.     Q = BoundedQueue(QL)
  956.     P = []
  957.     for i in range(NP):
  958.         t = ProducerThread(Q, NI)
  959.         t.name = ("Producer-%d" % (i+1))
  960.         P.append(t)
  961.     C = ConsumerThread(Q, NI*NP)
  962.     for t in P:
  963.         t.start()
  964.         _sleep(0.000001)
  965.     C.start()
  966.     for t in P:
  967.         t.join()
  968.     C.join()
  969.  
  970. if __name__ == '__main__':
  971.     _test()
  972.